| // Copyright 2015-2024 The Khronos Group Inc. |
| // |
| // SPDX-License-Identifier: Apache-2.0 OR MIT |
| // |
| |
| // This header is generated from the Khronos Vulkan XML API Registry. |
| |
| #ifndef VULKAN_FUNCS_HPP |
| #define VULKAN_FUNCS_HPP |
| |
| namespace VULKAN_HPP_NAMESPACE |
| { |
| |
| //=========================== |
| //=== COMMAND Definitions === |
| //=========================== |
| |
| //=== VK_VERSION_1_0 === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result createInstance( const VULKAN_HPP_NAMESPACE::InstanceCreateInfo * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::Instance * pInstance, |
| Dispatch const & d ) VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateInstance( reinterpret_cast<const VkInstanceCreateInfo *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkInstance *>( pInstance ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::Instance>::type createInstance( |
| const VULKAN_HPP_NAMESPACE::InstanceCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, Dispatch const & d ) |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateInstance && "Function <vkCreateInstance> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Instance instance; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateInstance( reinterpret_cast<const VkInstanceCreateInfo *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkInstance *>( &instance ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::createInstance" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( instance ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Instance, Dispatch>>::type createInstanceUnique( |
| const VULKAN_HPP_NAMESPACE::InstanceCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, Dispatch const & d ) |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateInstance && "Function <vkCreateInstance> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Instance instance; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateInstance( reinterpret_cast<const VkInstanceCreateInfo *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkInstance *>( &instance ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::createInstanceUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::Instance, Dispatch>( instance, ObjectDestroy<NoParent, Dispatch>( allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Instance::destroy( const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyInstance( m_instance, reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Instance::destroy( Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyInstance && "Function <vkDestroyInstance> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| d.vkDestroyInstance( m_instance, |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::enumeratePhysicalDevices( uint32_t * pPhysicalDeviceCount, |
| VULKAN_HPP_NAMESPACE::PhysicalDevice * pPhysicalDevices, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkEnumeratePhysicalDevices( m_instance, pPhysicalDeviceCount, reinterpret_cast<VkPhysicalDevice *>( pPhysicalDevices ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename PhysicalDeviceAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDevice, PhysicalDeviceAllocator>>::type |
| Instance::enumeratePhysicalDevices( Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkEnumeratePhysicalDevices && "Function <vkEnumeratePhysicalDevices> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::PhysicalDevice, PhysicalDeviceAllocator> physicalDevices; |
| uint32_t physicalDeviceCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkEnumeratePhysicalDevices( m_instance, &physicalDeviceCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && physicalDeviceCount ) |
| { |
| physicalDevices.resize( physicalDeviceCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkEnumeratePhysicalDevices( m_instance, &physicalDeviceCount, reinterpret_cast<VkPhysicalDevice *>( physicalDevices.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::enumeratePhysicalDevices" ); |
| VULKAN_HPP_ASSERT( physicalDeviceCount <= physicalDevices.size() ); |
| if ( physicalDeviceCount < physicalDevices.size() ) |
| { |
| physicalDevices.resize( physicalDeviceCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( physicalDevices ) ); |
| } |
| |
| template <typename PhysicalDeviceAllocator, |
| typename Dispatch, |
| typename std::enable_if<std::is_same<typename PhysicalDeviceAllocator::value_type, VULKAN_HPP_NAMESPACE::PhysicalDevice>::value, int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDevice, PhysicalDeviceAllocator>>::type |
| Instance::enumeratePhysicalDevices( PhysicalDeviceAllocator & physicalDeviceAllocator, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkEnumeratePhysicalDevices && "Function <vkEnumeratePhysicalDevices> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::PhysicalDevice, PhysicalDeviceAllocator> physicalDevices( physicalDeviceAllocator ); |
| uint32_t physicalDeviceCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkEnumeratePhysicalDevices( m_instance, &physicalDeviceCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && physicalDeviceCount ) |
| { |
| physicalDevices.resize( physicalDeviceCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkEnumeratePhysicalDevices( m_instance, &physicalDeviceCount, reinterpret_cast<VkPhysicalDevice *>( physicalDevices.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::enumeratePhysicalDevices" ); |
| VULKAN_HPP_ASSERT( physicalDeviceCount <= physicalDevices.size() ); |
| if ( physicalDeviceCount < physicalDevices.size() ) |
| { |
| physicalDevices.resize( physicalDeviceCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( physicalDevices ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void PhysicalDevice::getFeatures( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures * pFeatures, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetPhysicalDeviceFeatures( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures *>( pFeatures ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures |
| PhysicalDevice::getFeatures( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceFeatures && "Function <vkGetPhysicalDeviceFeatures> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures features; |
| d.vkGetPhysicalDeviceFeatures( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures *>( &features ) ); |
| |
| return features; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void PhysicalDevice::getFormatProperties( VULKAN_HPP_NAMESPACE::Format format, |
| VULKAN_HPP_NAMESPACE::FormatProperties * pFormatProperties, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetPhysicalDeviceFormatProperties( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties *>( pFormatProperties ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::FormatProperties |
| PhysicalDevice::getFormatProperties( VULKAN_HPP_NAMESPACE::Format format, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceFormatProperties && "Function <vkGetPhysicalDeviceFormatProperties> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::FormatProperties formatProperties; |
| d.vkGetPhysicalDeviceFormatProperties( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties *>( &formatProperties ) ); |
| |
| return formatProperties; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getImageFormatProperties( VULKAN_HPP_NAMESPACE::Format format, |
| VULKAN_HPP_NAMESPACE::ImageType type, |
| VULKAN_HPP_NAMESPACE::ImageTiling tiling, |
| VULKAN_HPP_NAMESPACE::ImageUsageFlags usage, |
| VULKAN_HPP_NAMESPACE::ImageCreateFlags flags, |
| VULKAN_HPP_NAMESPACE::ImageFormatProperties * pImageFormatProperties, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties( m_physicalDevice, |
| static_cast<VkFormat>( format ), |
| static_cast<VkImageType>( type ), |
| static_cast<VkImageTiling>( tiling ), |
| static_cast<VkImageUsageFlags>( usage ), |
| static_cast<VkImageCreateFlags>( flags ), |
| reinterpret_cast<VkImageFormatProperties *>( pImageFormatProperties ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageFormatProperties>::type |
| PhysicalDevice::getImageFormatProperties( VULKAN_HPP_NAMESPACE::Format format, |
| VULKAN_HPP_NAMESPACE::ImageType type, |
| VULKAN_HPP_NAMESPACE::ImageTiling tiling, |
| VULKAN_HPP_NAMESPACE::ImageUsageFlags usage, |
| VULKAN_HPP_NAMESPACE::ImageCreateFlags flags, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceImageFormatProperties && "Function <vkGetPhysicalDeviceImageFormatProperties> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::ImageFormatProperties imageFormatProperties; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetPhysicalDeviceImageFormatProperties( m_physicalDevice, |
| static_cast<VkFormat>( format ), |
| static_cast<VkImageType>( type ), |
| static_cast<VkImageTiling>( tiling ), |
| static_cast<VkImageUsageFlags>( usage ), |
| static_cast<VkImageCreateFlags>( flags ), |
| reinterpret_cast<VkImageFormatProperties *>( &imageFormatProperties ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( imageFormatProperties ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void PhysicalDevice::getProperties( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties * pProperties, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetPhysicalDeviceProperties( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties *>( pProperties ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties |
| PhysicalDevice::getProperties( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceProperties && "Function <vkGetPhysicalDeviceProperties> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties properties; |
| d.vkGetPhysicalDeviceProperties( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties *>( &properties ) ); |
| |
| return properties; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void PhysicalDevice::getQueueFamilyProperties( uint32_t * pQueueFamilyPropertyCount, |
| VULKAN_HPP_NAMESPACE::QueueFamilyProperties * pQueueFamilyProperties, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetPhysicalDeviceQueueFamilyProperties( |
| m_physicalDevice, pQueueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties *>( pQueueFamilyProperties ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename QueueFamilyPropertiesAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties, QueueFamilyPropertiesAllocator> |
| PhysicalDevice::getQueueFamilyProperties( Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyProperties && "Function <vkGetPhysicalDeviceQueueFamilyProperties> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties, QueueFamilyPropertiesAllocator> queueFamilyProperties; |
| uint32_t queueFamilyPropertyCount; |
| d.vkGetPhysicalDeviceQueueFamilyProperties( m_physicalDevice, &queueFamilyPropertyCount, nullptr ); |
| queueFamilyProperties.resize( queueFamilyPropertyCount ); |
| d.vkGetPhysicalDeviceQueueFamilyProperties( |
| m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties *>( queueFamilyProperties.data() ) ); |
| |
| VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() ); |
| if ( queueFamilyPropertyCount < queueFamilyProperties.size() ) |
| { |
| queueFamilyProperties.resize( queueFamilyPropertyCount ); |
| } |
| return queueFamilyProperties; |
| } |
| |
| template < |
| typename QueueFamilyPropertiesAllocator, |
| typename Dispatch, |
| typename std::enable_if<std::is_same<typename QueueFamilyPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::QueueFamilyProperties>::value, int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties, QueueFamilyPropertiesAllocator> |
| PhysicalDevice::getQueueFamilyProperties( QueueFamilyPropertiesAllocator & queueFamilyPropertiesAllocator, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyProperties && "Function <vkGetPhysicalDeviceQueueFamilyProperties> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties, QueueFamilyPropertiesAllocator> queueFamilyProperties( queueFamilyPropertiesAllocator ); |
| uint32_t queueFamilyPropertyCount; |
| d.vkGetPhysicalDeviceQueueFamilyProperties( m_physicalDevice, &queueFamilyPropertyCount, nullptr ); |
| queueFamilyProperties.resize( queueFamilyPropertyCount ); |
| d.vkGetPhysicalDeviceQueueFamilyProperties( |
| m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties *>( queueFamilyProperties.data() ) ); |
| |
| VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() ); |
| if ( queueFamilyPropertyCount < queueFamilyProperties.size() ) |
| { |
| queueFamilyProperties.resize( queueFamilyPropertyCount ); |
| } |
| return queueFamilyProperties; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void PhysicalDevice::getMemoryProperties( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties * pMemoryProperties, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetPhysicalDeviceMemoryProperties( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties *>( pMemoryProperties ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties |
| PhysicalDevice::getMemoryProperties( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceMemoryProperties && "Function <vkGetPhysicalDeviceMemoryProperties> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties memoryProperties; |
| d.vkGetPhysicalDeviceMemoryProperties( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties *>( &memoryProperties ) ); |
| |
| return memoryProperties; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE PFN_vkVoidFunction Instance::getProcAddr( const char * pName, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return d.vkGetInstanceProcAddr( m_instance, pName ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE PFN_vkVoidFunction Instance::getProcAddr( const std::string & name, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetInstanceProcAddr && "Function <vkGetInstanceProcAddr> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| PFN_vkVoidFunction result = d.vkGetInstanceProcAddr( m_instance, name.c_str() ); |
| |
| return result; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE PFN_vkVoidFunction Device::getProcAddr( const char * pName, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return d.vkGetDeviceProcAddr( m_device, pName ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE PFN_vkVoidFunction Device::getProcAddr( const std::string & name, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetDeviceProcAddr && "Function <vkGetDeviceProcAddr> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| PFN_vkVoidFunction result = d.vkGetDeviceProcAddr( m_device, name.c_str() ); |
| |
| return result; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::createDevice( const VULKAN_HPP_NAMESPACE::DeviceCreateInfo * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::Device * pDevice, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateDevice( m_physicalDevice, |
| reinterpret_cast<const VkDeviceCreateInfo *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkDevice *>( pDevice ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::Device>::type PhysicalDevice::createDevice( |
| const VULKAN_HPP_NAMESPACE::DeviceCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateDevice && "Function <vkCreateDevice> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Device device; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateDevice( m_physicalDevice, |
| reinterpret_cast<const VkDeviceCreateInfo *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkDevice *>( &device ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::createDevice" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( device ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Device, Dispatch>>::type |
| PhysicalDevice::createDeviceUnique( const VULKAN_HPP_NAMESPACE::DeviceCreateInfo & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateDevice && "Function <vkCreateDevice> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Device device; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateDevice( m_physicalDevice, |
| reinterpret_cast<const VkDeviceCreateInfo *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkDevice *>( &device ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::createDeviceUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::Device, Dispatch>( device, ObjectDestroy<NoParent, Dispatch>( allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyDevice( m_device, reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyDevice && "Function <vkDestroyDevice> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| d.vkDestroyDevice( m_device, |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result enumerateInstanceExtensionProperties( const char * pLayerName, |
| uint32_t * pPropertyCount, |
| VULKAN_HPP_NAMESPACE::ExtensionProperties * pProperties, |
| Dispatch const & d ) VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( |
| d.vkEnumerateInstanceExtensionProperties( pLayerName, pPropertyCount, reinterpret_cast<VkExtensionProperties *>( pProperties ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename ExtensionPropertiesAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties, ExtensionPropertiesAllocator>>::type |
| enumerateInstanceExtensionProperties( Optional<const std::string> layerName, Dispatch const & d ) |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkEnumerateInstanceExtensionProperties && "Function <vkEnumerateInstanceExtensionProperties> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties, ExtensionPropertiesAllocator> properties; |
| uint32_t propertyCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkEnumerateInstanceExtensionProperties( layerName ? layerName->c_str() : nullptr, &propertyCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount ) |
| { |
| properties.resize( propertyCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkEnumerateInstanceExtensionProperties( |
| layerName ? layerName->c_str() : nullptr, &propertyCount, reinterpret_cast<VkExtensionProperties *>( properties.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::enumerateInstanceExtensionProperties" ); |
| VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); |
| if ( propertyCount < properties.size() ) |
| { |
| properties.resize( propertyCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); |
| } |
| |
| template < |
| typename ExtensionPropertiesAllocator, |
| typename Dispatch, |
| typename std::enable_if<std::is_same<typename ExtensionPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::ExtensionProperties>::value, int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties, ExtensionPropertiesAllocator>>::type |
| enumerateInstanceExtensionProperties( Optional<const std::string> layerName, |
| ExtensionPropertiesAllocator & extensionPropertiesAllocator, |
| Dispatch const & d ) |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkEnumerateInstanceExtensionProperties && "Function <vkEnumerateInstanceExtensionProperties> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties, ExtensionPropertiesAllocator> properties( extensionPropertiesAllocator ); |
| uint32_t propertyCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkEnumerateInstanceExtensionProperties( layerName ? layerName->c_str() : nullptr, &propertyCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount ) |
| { |
| properties.resize( propertyCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkEnumerateInstanceExtensionProperties( |
| layerName ? layerName->c_str() : nullptr, &propertyCount, reinterpret_cast<VkExtensionProperties *>( properties.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::enumerateInstanceExtensionProperties" ); |
| VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); |
| if ( propertyCount < properties.size() ) |
| { |
| properties.resize( propertyCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::enumerateDeviceExtensionProperties( const char * pLayerName, |
| uint32_t * pPropertyCount, |
| VULKAN_HPP_NAMESPACE::ExtensionProperties * pProperties, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( |
| d.vkEnumerateDeviceExtensionProperties( m_physicalDevice, pLayerName, pPropertyCount, reinterpret_cast<VkExtensionProperties *>( pProperties ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename ExtensionPropertiesAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties, ExtensionPropertiesAllocator>>::type |
| PhysicalDevice::enumerateDeviceExtensionProperties( Optional<const std::string> layerName, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkEnumerateDeviceExtensionProperties && "Function <vkEnumerateDeviceExtensionProperties> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties, ExtensionPropertiesAllocator> properties; |
| uint32_t propertyCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkEnumerateDeviceExtensionProperties( m_physicalDevice, layerName ? layerName->c_str() : nullptr, &propertyCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount ) |
| { |
| properties.resize( propertyCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkEnumerateDeviceExtensionProperties( |
| m_physicalDevice, layerName ? layerName->c_str() : nullptr, &propertyCount, reinterpret_cast<VkExtensionProperties *>( properties.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateDeviceExtensionProperties" ); |
| VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); |
| if ( propertyCount < properties.size() ) |
| { |
| properties.resize( propertyCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); |
| } |
| |
| template < |
| typename ExtensionPropertiesAllocator, |
| typename Dispatch, |
| typename std::enable_if<std::is_same<typename ExtensionPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::ExtensionProperties>::value, int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties, ExtensionPropertiesAllocator>>::type |
| PhysicalDevice::enumerateDeviceExtensionProperties( Optional<const std::string> layerName, |
| ExtensionPropertiesAllocator & extensionPropertiesAllocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkEnumerateDeviceExtensionProperties && "Function <vkEnumerateDeviceExtensionProperties> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties, ExtensionPropertiesAllocator> properties( extensionPropertiesAllocator ); |
| uint32_t propertyCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkEnumerateDeviceExtensionProperties( m_physicalDevice, layerName ? layerName->c_str() : nullptr, &propertyCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount ) |
| { |
| properties.resize( propertyCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkEnumerateDeviceExtensionProperties( |
| m_physicalDevice, layerName ? layerName->c_str() : nullptr, &propertyCount, reinterpret_cast<VkExtensionProperties *>( properties.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateDeviceExtensionProperties" ); |
| VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); |
| if ( propertyCount < properties.size() ) |
| { |
| properties.resize( propertyCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result enumerateInstanceLayerProperties( uint32_t * pPropertyCount, |
| VULKAN_HPP_NAMESPACE::LayerProperties * pProperties, |
| Dispatch const & d ) VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkEnumerateInstanceLayerProperties( pPropertyCount, reinterpret_cast<VkLayerProperties *>( pProperties ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename LayerPropertiesAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::LayerProperties, LayerPropertiesAllocator>>::type |
| enumerateInstanceLayerProperties( Dispatch const & d ) |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkEnumerateInstanceLayerProperties && "Function <vkEnumerateInstanceLayerProperties> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::LayerProperties, LayerPropertiesAllocator> properties; |
| uint32_t propertyCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkEnumerateInstanceLayerProperties( &propertyCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount ) |
| { |
| properties.resize( propertyCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkEnumerateInstanceLayerProperties( &propertyCount, reinterpret_cast<VkLayerProperties *>( properties.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::enumerateInstanceLayerProperties" ); |
| VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); |
| if ( propertyCount < properties.size() ) |
| { |
| properties.resize( propertyCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); |
| } |
| |
| template <typename LayerPropertiesAllocator, |
| typename Dispatch, |
| typename std::enable_if<std::is_same<typename LayerPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::LayerProperties>::value, int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::LayerProperties, LayerPropertiesAllocator>>::type |
| enumerateInstanceLayerProperties( LayerPropertiesAllocator & layerPropertiesAllocator, Dispatch const & d ) |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkEnumerateInstanceLayerProperties && "Function <vkEnumerateInstanceLayerProperties> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::LayerProperties, LayerPropertiesAllocator> properties( layerPropertiesAllocator ); |
| uint32_t propertyCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkEnumerateInstanceLayerProperties( &propertyCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount ) |
| { |
| properties.resize( propertyCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkEnumerateInstanceLayerProperties( &propertyCount, reinterpret_cast<VkLayerProperties *>( properties.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::enumerateInstanceLayerProperties" ); |
| VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); |
| if ( propertyCount < properties.size() ) |
| { |
| properties.resize( propertyCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::enumerateDeviceLayerProperties( uint32_t * pPropertyCount, |
| VULKAN_HPP_NAMESPACE::LayerProperties * pProperties, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkEnumerateDeviceLayerProperties( m_physicalDevice, pPropertyCount, reinterpret_cast<VkLayerProperties *>( pProperties ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename LayerPropertiesAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::LayerProperties, LayerPropertiesAllocator>>::type |
| PhysicalDevice::enumerateDeviceLayerProperties( Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkEnumerateDeviceLayerProperties && "Function <vkEnumerateDeviceLayerProperties> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::LayerProperties, LayerPropertiesAllocator> properties; |
| uint32_t propertyCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkEnumerateDeviceLayerProperties( m_physicalDevice, &propertyCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount ) |
| { |
| properties.resize( propertyCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkEnumerateDeviceLayerProperties( m_physicalDevice, &propertyCount, reinterpret_cast<VkLayerProperties *>( properties.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateDeviceLayerProperties" ); |
| VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); |
| if ( propertyCount < properties.size() ) |
| { |
| properties.resize( propertyCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); |
| } |
| |
| template <typename LayerPropertiesAllocator, |
| typename Dispatch, |
| typename std::enable_if<std::is_same<typename LayerPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::LayerProperties>::value, int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::LayerProperties, LayerPropertiesAllocator>>::type |
| PhysicalDevice::enumerateDeviceLayerProperties( LayerPropertiesAllocator & layerPropertiesAllocator, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkEnumerateDeviceLayerProperties && "Function <vkEnumerateDeviceLayerProperties> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::LayerProperties, LayerPropertiesAllocator> properties( layerPropertiesAllocator ); |
| uint32_t propertyCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkEnumerateDeviceLayerProperties( m_physicalDevice, &propertyCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount ) |
| { |
| properties.resize( propertyCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkEnumerateDeviceLayerProperties( m_physicalDevice, &propertyCount, reinterpret_cast<VkLayerProperties *>( properties.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateDeviceLayerProperties" ); |
| VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); |
| if ( propertyCount < properties.size() ) |
| { |
| properties.resize( propertyCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void |
| Device::getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex, VULKAN_HPP_NAMESPACE::Queue * pQueue, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetDeviceQueue( m_device, queueFamilyIndex, queueIndex, reinterpret_cast<VkQueue *>( pQueue ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Queue |
| Device::getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetDeviceQueue && "Function <vkGetDeviceQueue> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Queue queue; |
| d.vkGetDeviceQueue( m_device, queueFamilyIndex, queueIndex, reinterpret_cast<VkQueue *>( &queue ) ); |
| |
| return queue; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Queue::submit( uint32_t submitCount, |
| const VULKAN_HPP_NAMESPACE::SubmitInfo * pSubmits, |
| VULKAN_HPP_NAMESPACE::Fence fence, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkQueueSubmit( m_queue, submitCount, reinterpret_cast<const VkSubmitInfo *>( pSubmits ), static_cast<VkFence>( fence ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type Queue::submit( |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo> const & submits, VULKAN_HPP_NAMESPACE::Fence fence, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkQueueSubmit && "Function <vkQueueSubmit> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkQueueSubmit( m_queue, submits.size(), reinterpret_cast<const VkSubmitInfo *>( submits.data() ), static_cast<VkFence>( fence ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::submit" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Queue::waitIdle( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkQueueWaitIdle( m_queue ) ); |
| } |
| #else |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type Queue::waitIdle( Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkQueueWaitIdle && "Function <vkQueueWaitIdle> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkQueueWaitIdle( m_queue ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::waitIdle" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::waitIdle( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkDeviceWaitIdle( m_device ) ); |
| } |
| #else |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::waitIdle( Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDeviceWaitIdle && "Function <vkDeviceWaitIdle> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkDeviceWaitIdle( m_device ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::waitIdle" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::allocateMemory( const VULKAN_HPP_NAMESPACE::MemoryAllocateInfo * pAllocateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::DeviceMemory * pMemory, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkAllocateMemory( m_device, |
| reinterpret_cast<const VkMemoryAllocateInfo *>( pAllocateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkDeviceMemory *>( pMemory ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceMemory>::type |
| Device::allocateMemory( const VULKAN_HPP_NAMESPACE::MemoryAllocateInfo & allocateInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkAllocateMemory && "Function <vkAllocateMemory> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::DeviceMemory memory; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkAllocateMemory( m_device, |
| reinterpret_cast<const VkMemoryAllocateInfo *>( &allocateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkDeviceMemory *>( &memory ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateMemory" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( memory ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DeviceMemory, Dispatch>>::type |
| Device::allocateMemoryUnique( const VULKAN_HPP_NAMESPACE::MemoryAllocateInfo & allocateInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkAllocateMemory && "Function <vkAllocateMemory> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::DeviceMemory memory; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkAllocateMemory( m_device, |
| reinterpret_cast<const VkMemoryAllocateInfo *>( &allocateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkDeviceMemory *>( &memory ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateMemoryUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::DeviceMemory, Dispatch>( memory, ObjectFree<Device, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::freeMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkFreeMemory( m_device, static_cast<VkDeviceMemory>( memory ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::freeMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkFreeMemory && "Function <vkFreeMemory> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| d.vkFreeMemory( m_device, |
| static_cast<VkDeviceMemory>( memory ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void( Device::free )( VULKAN_HPP_NAMESPACE::DeviceMemory memory, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkFreeMemory( m_device, static_cast<VkDeviceMemory>( memory ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void( Device::free )( VULKAN_HPP_NAMESPACE::DeviceMemory memory, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkFreeMemory && "Function <vkFreeMemory> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| d.vkFreeMemory( m_device, |
| static_cast<VkDeviceMemory>( memory ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::mapMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory, |
| VULKAN_HPP_NAMESPACE::DeviceSize offset, |
| VULKAN_HPP_NAMESPACE::DeviceSize size, |
| VULKAN_HPP_NAMESPACE::MemoryMapFlags flags, |
| void ** ppData, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkMapMemory( m_device, |
| static_cast<VkDeviceMemory>( memory ), |
| static_cast<VkDeviceSize>( offset ), |
| static_cast<VkDeviceSize>( size ), |
| static_cast<VkMemoryMapFlags>( flags ), |
| ppData ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<void *>::type Device::mapMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory, |
| VULKAN_HPP_NAMESPACE::DeviceSize offset, |
| VULKAN_HPP_NAMESPACE::DeviceSize size, |
| VULKAN_HPP_NAMESPACE::MemoryMapFlags flags, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkMapMemory && "Function <vkMapMemory> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| void * pData; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkMapMemory( m_device, |
| static_cast<VkDeviceMemory>( memory ), |
| static_cast<VkDeviceSize>( offset ), |
| static_cast<VkDeviceSize>( size ), |
| static_cast<VkMemoryMapFlags>( flags ), |
| &pData ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::mapMemory" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( pData ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::unmapMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkUnmapMemory( m_device, static_cast<VkDeviceMemory>( memory ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::flushMappedMemoryRanges( uint32_t memoryRangeCount, |
| const VULKAN_HPP_NAMESPACE::MappedMemoryRange * pMemoryRanges, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkFlushMappedMemoryRanges( m_device, memoryRangeCount, reinterpret_cast<const VkMappedMemoryRange *>( pMemoryRanges ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type |
| Device::flushMappedMemoryRanges( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const & memoryRanges, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkFlushMappedMemoryRanges && "Function <vkFlushMappedMemoryRanges> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkFlushMappedMemoryRanges( m_device, memoryRanges.size(), reinterpret_cast<const VkMappedMemoryRange *>( memoryRanges.data() ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::flushMappedMemoryRanges" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::invalidateMappedMemoryRanges( uint32_t memoryRangeCount, |
| const VULKAN_HPP_NAMESPACE::MappedMemoryRange * pMemoryRanges, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( |
| d.vkInvalidateMappedMemoryRanges( m_device, memoryRangeCount, reinterpret_cast<const VkMappedMemoryRange *>( pMemoryRanges ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type |
| Device::invalidateMappedMemoryRanges( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const & memoryRanges, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkInvalidateMappedMemoryRanges && "Function <vkInvalidateMappedMemoryRanges> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkInvalidateMappedMemoryRanges( m_device, memoryRanges.size(), reinterpret_cast<const VkMappedMemoryRange *>( memoryRanges.data() ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::invalidateMappedMemoryRanges" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::getMemoryCommitment( VULKAN_HPP_NAMESPACE::DeviceMemory memory, |
| VULKAN_HPP_NAMESPACE::DeviceSize * pCommittedMemoryInBytes, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetDeviceMemoryCommitment( m_device, static_cast<VkDeviceMemory>( memory ), reinterpret_cast<VkDeviceSize *>( pCommittedMemoryInBytes ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceSize Device::getMemoryCommitment( VULKAN_HPP_NAMESPACE::DeviceMemory memory, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetDeviceMemoryCommitment && "Function <vkGetDeviceMemoryCommitment> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::DeviceSize committedMemoryInBytes; |
| d.vkGetDeviceMemoryCommitment( m_device, static_cast<VkDeviceMemory>( memory ), reinterpret_cast<VkDeviceSize *>( &committedMemoryInBytes ) ); |
| |
| return committedMemoryInBytes; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::bindBufferMemory( VULKAN_HPP_NAMESPACE::Buffer buffer, |
| VULKAN_HPP_NAMESPACE::DeviceMemory memory, |
| VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( |
| d.vkBindBufferMemory( m_device, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceMemory>( memory ), static_cast<VkDeviceSize>( memoryOffset ) ) ); |
| } |
| #else |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::bindBufferMemory( |
| VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceMemory memory, VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkBindBufferMemory && "Function <vkBindBufferMemory> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkBindBufferMemory( m_device, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceMemory>( memory ), static_cast<VkDeviceSize>( memoryOffset ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindBufferMemory" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::bindImageMemory( VULKAN_HPP_NAMESPACE::Image image, |
| VULKAN_HPP_NAMESPACE::DeviceMemory memory, |
| VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( |
| d.vkBindImageMemory( m_device, static_cast<VkImage>( image ), static_cast<VkDeviceMemory>( memory ), static_cast<VkDeviceSize>( memoryOffset ) ) ); |
| } |
| #else |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::bindImageMemory( |
| VULKAN_HPP_NAMESPACE::Image image, VULKAN_HPP_NAMESPACE::DeviceMemory memory, VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkBindImageMemory && "Function <vkBindImageMemory> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkBindImageMemory( m_device, static_cast<VkImage>( image ), static_cast<VkDeviceMemory>( memory ), static_cast<VkDeviceSize>( memoryOffset ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindImageMemory" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::getBufferMemoryRequirements( VULKAN_HPP_NAMESPACE::Buffer buffer, |
| VULKAN_HPP_NAMESPACE::MemoryRequirements * pMemoryRequirements, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetBufferMemoryRequirements( m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<VkMemoryRequirements *>( pMemoryRequirements ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements |
| Device::getBufferMemoryRequirements( VULKAN_HPP_NAMESPACE::Buffer buffer, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetBufferMemoryRequirements && "Function <vkGetBufferMemoryRequirements> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::MemoryRequirements memoryRequirements; |
| d.vkGetBufferMemoryRequirements( m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<VkMemoryRequirements *>( &memoryRequirements ) ); |
| |
| return memoryRequirements; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::getImageMemoryRequirements( VULKAN_HPP_NAMESPACE::Image image, |
| VULKAN_HPP_NAMESPACE::MemoryRequirements * pMemoryRequirements, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetImageMemoryRequirements( m_device, static_cast<VkImage>( image ), reinterpret_cast<VkMemoryRequirements *>( pMemoryRequirements ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements |
| Device::getImageMemoryRequirements( VULKAN_HPP_NAMESPACE::Image image, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetImageMemoryRequirements && "Function <vkGetImageMemoryRequirements> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::MemoryRequirements memoryRequirements; |
| d.vkGetImageMemoryRequirements( m_device, static_cast<VkImage>( image ), reinterpret_cast<VkMemoryRequirements *>( &memoryRequirements ) ); |
| |
| return memoryRequirements; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirements( VULKAN_HPP_NAMESPACE::Image image, |
| uint32_t * pSparseMemoryRequirementCount, |
| VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements * pSparseMemoryRequirements, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetImageSparseMemoryRequirements( m_device, |
| static_cast<VkImage>( image ), |
| pSparseMemoryRequirementCount, |
| reinterpret_cast<VkSparseImageMemoryRequirements *>( pSparseMemoryRequirements ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename SparseImageMemoryRequirementsAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator> |
| Device::getImageSparseMemoryRequirements( VULKAN_HPP_NAMESPACE::Image image, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetImageSparseMemoryRequirements && "Function <vkGetImageSparseMemoryRequirements> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator> sparseMemoryRequirements; |
| uint32_t sparseMemoryRequirementCount; |
| d.vkGetImageSparseMemoryRequirements( m_device, static_cast<VkImage>( image ), &sparseMemoryRequirementCount, nullptr ); |
| sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); |
| d.vkGetImageSparseMemoryRequirements( m_device, |
| static_cast<VkImage>( image ), |
| &sparseMemoryRequirementCount, |
| reinterpret_cast<VkSparseImageMemoryRequirements *>( sparseMemoryRequirements.data() ) ); |
| |
| VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() ); |
| if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() ) |
| { |
| sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); |
| } |
| return sparseMemoryRequirements; |
| } |
| |
| template <typename SparseImageMemoryRequirementsAllocator, |
| typename Dispatch, |
| typename std::enable_if< |
| std::is_same<typename SparseImageMemoryRequirementsAllocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements>::value, |
| int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator> |
| Device::getImageSparseMemoryRequirements( VULKAN_HPP_NAMESPACE::Image image, |
| SparseImageMemoryRequirementsAllocator & sparseImageMemoryRequirementsAllocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetImageSparseMemoryRequirements && "Function <vkGetImageSparseMemoryRequirements> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator> sparseMemoryRequirements( |
| sparseImageMemoryRequirementsAllocator ); |
| uint32_t sparseMemoryRequirementCount; |
| d.vkGetImageSparseMemoryRequirements( m_device, static_cast<VkImage>( image ), &sparseMemoryRequirementCount, nullptr ); |
| sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); |
| d.vkGetImageSparseMemoryRequirements( m_device, |
| static_cast<VkImage>( image ), |
| &sparseMemoryRequirementCount, |
| reinterpret_cast<VkSparseImageMemoryRequirements *>( sparseMemoryRequirements.data() ) ); |
| |
| VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() ); |
| if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() ) |
| { |
| sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); |
| } |
| return sparseMemoryRequirements; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void PhysicalDevice::getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format format, |
| VULKAN_HPP_NAMESPACE::ImageType type, |
| VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples, |
| VULKAN_HPP_NAMESPACE::ImageUsageFlags usage, |
| VULKAN_HPP_NAMESPACE::ImageTiling tiling, |
| uint32_t * pPropertyCount, |
| VULKAN_HPP_NAMESPACE::SparseImageFormatProperties * pProperties, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetPhysicalDeviceSparseImageFormatProperties( m_physicalDevice, |
| static_cast<VkFormat>( format ), |
| static_cast<VkImageType>( type ), |
| static_cast<VkSampleCountFlagBits>( samples ), |
| static_cast<VkImageUsageFlags>( usage ), |
| static_cast<VkImageTiling>( tiling ), |
| pPropertyCount, |
| reinterpret_cast<VkSparseImageFormatProperties *>( pProperties ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename SparseImageFormatPropertiesAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties, SparseImageFormatPropertiesAllocator> |
| PhysicalDevice::getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format format, |
| VULKAN_HPP_NAMESPACE::ImageType type, |
| VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples, |
| VULKAN_HPP_NAMESPACE::ImageUsageFlags usage, |
| VULKAN_HPP_NAMESPACE::ImageTiling tiling, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSparseImageFormatProperties && |
| "Function <vkGetPhysicalDeviceSparseImageFormatProperties> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties, SparseImageFormatPropertiesAllocator> properties; |
| uint32_t propertyCount; |
| d.vkGetPhysicalDeviceSparseImageFormatProperties( m_physicalDevice, |
| static_cast<VkFormat>( format ), |
| static_cast<VkImageType>( type ), |
| static_cast<VkSampleCountFlagBits>( samples ), |
| static_cast<VkImageUsageFlags>( usage ), |
| static_cast<VkImageTiling>( tiling ), |
| &propertyCount, |
| nullptr ); |
| properties.resize( propertyCount ); |
| d.vkGetPhysicalDeviceSparseImageFormatProperties( m_physicalDevice, |
| static_cast<VkFormat>( format ), |
| static_cast<VkImageType>( type ), |
| static_cast<VkSampleCountFlagBits>( samples ), |
| static_cast<VkImageUsageFlags>( usage ), |
| static_cast<VkImageTiling>( tiling ), |
| &propertyCount, |
| reinterpret_cast<VkSparseImageFormatProperties *>( properties.data() ) ); |
| |
| VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); |
| if ( propertyCount < properties.size() ) |
| { |
| properties.resize( propertyCount ); |
| } |
| return properties; |
| } |
| |
| template < |
| typename SparseImageFormatPropertiesAllocator, |
| typename Dispatch, |
| typename std::enable_if<std::is_same<typename SparseImageFormatPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageFormatProperties>::value, |
| int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties, SparseImageFormatPropertiesAllocator> |
| PhysicalDevice::getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format format, |
| VULKAN_HPP_NAMESPACE::ImageType type, |
| VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples, |
| VULKAN_HPP_NAMESPACE::ImageUsageFlags usage, |
| VULKAN_HPP_NAMESPACE::ImageTiling tiling, |
| SparseImageFormatPropertiesAllocator & sparseImageFormatPropertiesAllocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSparseImageFormatProperties && |
| "Function <vkGetPhysicalDeviceSparseImageFormatProperties> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties, SparseImageFormatPropertiesAllocator> properties( sparseImageFormatPropertiesAllocator ); |
| uint32_t propertyCount; |
| d.vkGetPhysicalDeviceSparseImageFormatProperties( m_physicalDevice, |
| static_cast<VkFormat>( format ), |
| static_cast<VkImageType>( type ), |
| static_cast<VkSampleCountFlagBits>( samples ), |
| static_cast<VkImageUsageFlags>( usage ), |
| static_cast<VkImageTiling>( tiling ), |
| &propertyCount, |
| nullptr ); |
| properties.resize( propertyCount ); |
| d.vkGetPhysicalDeviceSparseImageFormatProperties( m_physicalDevice, |
| static_cast<VkFormat>( format ), |
| static_cast<VkImageType>( type ), |
| static_cast<VkSampleCountFlagBits>( samples ), |
| static_cast<VkImageUsageFlags>( usage ), |
| static_cast<VkImageTiling>( tiling ), |
| &propertyCount, |
| reinterpret_cast<VkSparseImageFormatProperties *>( properties.data() ) ); |
| |
| VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); |
| if ( propertyCount < properties.size() ) |
| { |
| properties.resize( propertyCount ); |
| } |
| return properties; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Queue::bindSparse( uint32_t bindInfoCount, |
| const VULKAN_HPP_NAMESPACE::BindSparseInfo * pBindInfo, |
| VULKAN_HPP_NAMESPACE::Fence fence, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( |
| d.vkQueueBindSparse( m_queue, bindInfoCount, reinterpret_cast<const VkBindSparseInfo *>( pBindInfo ), static_cast<VkFence>( fence ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type Queue::bindSparse( |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindSparseInfo> const & bindInfo, VULKAN_HPP_NAMESPACE::Fence fence, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkQueueBindSparse && "Function <vkQueueBindSparse> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkQueueBindSparse( m_queue, bindInfo.size(), reinterpret_cast<const VkBindSparseInfo *>( bindInfo.data() ), static_cast<VkFence>( fence ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::bindSparse" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createFence( const VULKAN_HPP_NAMESPACE::FenceCreateInfo * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::Fence * pFence, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateFence( m_device, |
| reinterpret_cast<const VkFenceCreateInfo *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkFence *>( pFence ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::Fence>::type Device::createFence( |
| const VULKAN_HPP_NAMESPACE::FenceCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateFence && "Function <vkCreateFence> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Fence fence; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateFence( m_device, |
| reinterpret_cast<const VkFenceCreateInfo *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkFence *>( &fence ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createFence" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( fence ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>>::type Device::createFenceUnique( |
| const VULKAN_HPP_NAMESPACE::FenceCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateFence && "Function <vkCreateFence> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Fence fence; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateFence( m_device, |
| reinterpret_cast<const VkFenceCreateInfo *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkFence *>( &fence ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createFenceUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>( fence, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyFence( VULKAN_HPP_NAMESPACE::Fence fence, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyFence( m_device, static_cast<VkFence>( fence ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyFence( VULKAN_HPP_NAMESPACE::Fence fence, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyFence && "Function <vkDestroyFence> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| d.vkDestroyFence( m_device, |
| static_cast<VkFence>( fence ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Fence fence, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyFence( m_device, static_cast<VkFence>( fence ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Fence fence, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyFence && "Function <vkDestroyFence> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| d.vkDestroyFence( m_device, |
| static_cast<VkFence>( fence ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::resetFences( uint32_t fenceCount, |
| const VULKAN_HPP_NAMESPACE::Fence * pFences, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkResetFences( m_device, fenceCount, reinterpret_cast<const VkFence *>( pFences ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE typename ResultValueType<void>::type |
| Device::resetFences( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const & fences, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkResetFences && "Function <vkResetFences> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = |
| static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkResetFences( m_device, fences.size(), reinterpret_cast<const VkFence *>( fences.data() ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::resetFences" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getFenceStatus( VULKAN_HPP_NAMESPACE::Fence fence, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetFenceStatus( m_device, static_cast<VkFence>( fence ) ) ); |
| } |
| #else |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result Device::getFenceStatus( VULKAN_HPP_NAMESPACE::Fence fence, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetFenceStatus && "Function <vkGetFenceStatus> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetFenceStatus( m_device, static_cast<VkFence>( fence ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( |
| result, VULKAN_HPP_NAMESPACE_STRING "::Device::getFenceStatus", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eNotReady } ); |
| |
| return static_cast<VULKAN_HPP_NAMESPACE::Result>( result ); |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::waitForFences( uint32_t fenceCount, |
| const VULKAN_HPP_NAMESPACE::Fence * pFences, |
| VULKAN_HPP_NAMESPACE::Bool32 waitAll, |
| uint64_t timeout, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( |
| d.vkWaitForFences( m_device, fenceCount, reinterpret_cast<const VkFence *>( pFences ), static_cast<VkBool32>( waitAll ), timeout ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result |
| Device::waitForFences( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const & fences, |
| VULKAN_HPP_NAMESPACE::Bool32 waitAll, |
| uint64_t timeout, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkWaitForFences && "Function <vkWaitForFences> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkWaitForFences( m_device, fences.size(), reinterpret_cast<const VkFence *>( fences.data() ), static_cast<VkBool32>( waitAll ), timeout ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( |
| result, VULKAN_HPP_NAMESPACE_STRING "::Device::waitForFences", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eTimeout } ); |
| |
| return static_cast<VULKAN_HPP_NAMESPACE::Result>( result ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::Semaphore * pSemaphore, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateSemaphore( m_device, |
| reinterpret_cast<const VkSemaphoreCreateInfo *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkSemaphore *>( pSemaphore ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::Semaphore>::type |
| Device::createSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateSemaphore && "Function <vkCreateSemaphore> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Semaphore semaphore; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateSemaphore( m_device, |
| reinterpret_cast<const VkSemaphoreCreateInfo *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkSemaphore *>( &semaphore ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSemaphore" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( semaphore ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Semaphore, Dispatch>>::type |
| Device::createSemaphoreUnique( const VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateSemaphore && "Function <vkCreateSemaphore> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Semaphore semaphore; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateSemaphore( m_device, |
| reinterpret_cast<const VkSemaphoreCreateInfo *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkSemaphore *>( &semaphore ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSemaphoreUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::Semaphore, Dispatch>( semaphore, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroySemaphore( VULKAN_HPP_NAMESPACE::Semaphore semaphore, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroySemaphore( m_device, static_cast<VkSemaphore>( semaphore ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroySemaphore( VULKAN_HPP_NAMESPACE::Semaphore semaphore, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroySemaphore && "Function <vkDestroySemaphore> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| d.vkDestroySemaphore( m_device, |
| static_cast<VkSemaphore>( semaphore ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Semaphore semaphore, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroySemaphore( m_device, static_cast<VkSemaphore>( semaphore ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Semaphore semaphore, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroySemaphore && "Function <vkDestroySemaphore> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| d.vkDestroySemaphore( m_device, |
| static_cast<VkSemaphore>( semaphore ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createEvent( const VULKAN_HPP_NAMESPACE::EventCreateInfo * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::Event * pEvent, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateEvent( m_device, |
| reinterpret_cast<const VkEventCreateInfo *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkEvent *>( pEvent ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::Event>::type Device::createEvent( |
| const VULKAN_HPP_NAMESPACE::EventCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateEvent && "Function <vkCreateEvent> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Event event; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateEvent( m_device, |
| reinterpret_cast<const VkEventCreateInfo *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkEvent *>( &event ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createEvent" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( event ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Event, Dispatch>>::type Device::createEventUnique( |
| const VULKAN_HPP_NAMESPACE::EventCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateEvent && "Function <vkCreateEvent> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Event event; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateEvent( m_device, |
| reinterpret_cast<const VkEventCreateInfo *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkEvent *>( &event ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createEventUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::Event, Dispatch>( event, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyEvent( VULKAN_HPP_NAMESPACE::Event event, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyEvent( m_device, static_cast<VkEvent>( event ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyEvent( VULKAN_HPP_NAMESPACE::Event event, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyEvent && "Function <vkDestroyEvent> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| d.vkDestroyEvent( m_device, |
| static_cast<VkEvent>( event ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Event event, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyEvent( m_device, static_cast<VkEvent>( event ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Event event, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyEvent && "Function <vkDestroyEvent> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| d.vkDestroyEvent( m_device, |
| static_cast<VkEvent>( event ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getEventStatus( VULKAN_HPP_NAMESPACE::Event event, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetEventStatus( m_device, static_cast<VkEvent>( event ) ) ); |
| } |
| #else |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result Device::getEventStatus( VULKAN_HPP_NAMESPACE::Event event, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetEventStatus && "Function <vkGetEventStatus> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetEventStatus( m_device, static_cast<VkEvent>( event ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( |
| result, VULKAN_HPP_NAMESPACE_STRING "::Device::getEventStatus", { VULKAN_HPP_NAMESPACE::Result::eEventSet, VULKAN_HPP_NAMESPACE::Result::eEventReset } ); |
| |
| return static_cast<VULKAN_HPP_NAMESPACE::Result>( result ); |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::setEvent( VULKAN_HPP_NAMESPACE::Event event, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkSetEvent( m_device, static_cast<VkEvent>( event ) ) ); |
| } |
| #else |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::setEvent( VULKAN_HPP_NAMESPACE::Event event, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkSetEvent && "Function <vkSetEvent> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkSetEvent( m_device, static_cast<VkEvent>( event ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setEvent" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::resetEvent( VULKAN_HPP_NAMESPACE::Event event, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkResetEvent( m_device, static_cast<VkEvent>( event ) ) ); |
| } |
| #else |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::resetEvent( VULKAN_HPP_NAMESPACE::Event event, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkResetEvent && "Function <vkResetEvent> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkResetEvent( m_device, static_cast<VkEvent>( event ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::resetEvent" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createQueryPool( const VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::QueryPool * pQueryPool, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateQueryPool( m_device, |
| reinterpret_cast<const VkQueryPoolCreateInfo *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkQueryPool *>( pQueryPool ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::QueryPool>::type |
| Device::createQueryPool( const VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateQueryPool && "Function <vkCreateQueryPool> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::QueryPool queryPool; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateQueryPool( m_device, |
| reinterpret_cast<const VkQueryPoolCreateInfo *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkQueryPool *>( &queryPool ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createQueryPool" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( queryPool ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::QueryPool, Dispatch>>::type |
| Device::createQueryPoolUnique( const VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateQueryPool && "Function <vkCreateQueryPool> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::QueryPool queryPool; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateQueryPool( m_device, |
| reinterpret_cast<const VkQueryPoolCreateInfo *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkQueryPool *>( &queryPool ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createQueryPoolUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::QueryPool, Dispatch>( queryPool, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyQueryPool( m_device, static_cast<VkQueryPool>( queryPool ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyQueryPool && "Function <vkDestroyQueryPool> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| d.vkDestroyQueryPool( m_device, |
| static_cast<VkQueryPool>( queryPool ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::QueryPool queryPool, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyQueryPool( m_device, static_cast<VkQueryPool>( queryPool ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::QueryPool queryPool, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyQueryPool && "Function <vkDestroyQueryPool> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| d.vkDestroyQueryPool( m_device, |
| static_cast<VkQueryPool>( queryPool ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool queryPool, |
| uint32_t firstQuery, |
| uint32_t queryCount, |
| size_t dataSize, |
| void * pData, |
| VULKAN_HPP_NAMESPACE::DeviceSize stride, |
| VULKAN_HPP_NAMESPACE::QueryResultFlags flags, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetQueryPoolResults( m_device, |
| static_cast<VkQueryPool>( queryPool ), |
| firstQuery, |
| queryCount, |
| dataSize, |
| pData, |
| static_cast<VkDeviceSize>( stride ), |
| static_cast<VkQueryResultFlags>( flags ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename DataType, typename DataTypeAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<DataType, DataTypeAllocator>> |
| Device::getQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool queryPool, |
| uint32_t firstQuery, |
| uint32_t queryCount, |
| size_t dataSize, |
| VULKAN_HPP_NAMESPACE::DeviceSize stride, |
| VULKAN_HPP_NAMESPACE::QueryResultFlags flags, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetQueryPoolResults && "Function <vkGetQueryPoolResults> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 ); |
| std::vector<DataType, DataTypeAllocator> data( dataSize / sizeof( DataType ) ); |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetQueryPoolResults( m_device, |
| static_cast<VkQueryPool>( queryPool ), |
| firstQuery, |
| queryCount, |
| data.size() * sizeof( DataType ), |
| reinterpret_cast<void *>( data.data() ), |
| static_cast<VkDeviceSize>( stride ), |
| static_cast<VkQueryResultFlags>( flags ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, |
| VULKAN_HPP_NAMESPACE_STRING "::Device::getQueryPoolResults", |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eNotReady } ); |
| |
| return ResultValue<std::vector<DataType, DataTypeAllocator>>( result, std::move( data ) ); |
| } |
| |
| template <typename DataType, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<DataType> Device::getQueryPoolResult( VULKAN_HPP_NAMESPACE::QueryPool queryPool, |
| uint32_t firstQuery, |
| uint32_t queryCount, |
| VULKAN_HPP_NAMESPACE::DeviceSize stride, |
| VULKAN_HPP_NAMESPACE::QueryResultFlags flags, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetQueryPoolResults && "Function <vkGetQueryPoolResults> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| DataType data; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetQueryPoolResults( m_device, |
| static_cast<VkQueryPool>( queryPool ), |
| firstQuery, |
| queryCount, |
| sizeof( DataType ), |
| reinterpret_cast<void *>( &data ), |
| static_cast<VkDeviceSize>( stride ), |
| static_cast<VkQueryResultFlags>( flags ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( |
| result, VULKAN_HPP_NAMESPACE_STRING "::Device::getQueryPoolResult", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eNotReady } ); |
| |
| return ResultValue<DataType>( result, std::move( data ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createBuffer( const VULKAN_HPP_NAMESPACE::BufferCreateInfo * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::Buffer * pBuffer, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateBuffer( m_device, |
| reinterpret_cast<const VkBufferCreateInfo *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkBuffer *>( pBuffer ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::Buffer>::type Device::createBuffer( |
| const VULKAN_HPP_NAMESPACE::BufferCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateBuffer && "Function <vkCreateBuffer> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Buffer buffer; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateBuffer( m_device, |
| reinterpret_cast<const VkBufferCreateInfo *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkBuffer *>( &buffer ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createBuffer" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( buffer ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Buffer, Dispatch>>::type Device::createBufferUnique( |
| const VULKAN_HPP_NAMESPACE::BufferCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateBuffer && "Function <vkCreateBuffer> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Buffer buffer; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateBuffer( m_device, |
| reinterpret_cast<const VkBufferCreateInfo *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkBuffer *>( &buffer ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createBufferUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::Buffer, Dispatch>( buffer, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyBuffer( VULKAN_HPP_NAMESPACE::Buffer buffer, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyBuffer( m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyBuffer( VULKAN_HPP_NAMESPACE::Buffer buffer, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyBuffer && "Function <vkDestroyBuffer> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| d.vkDestroyBuffer( m_device, |
| static_cast<VkBuffer>( buffer ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Buffer buffer, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyBuffer( m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Buffer buffer, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyBuffer && "Function <vkDestroyBuffer> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| d.vkDestroyBuffer( m_device, |
| static_cast<VkBuffer>( buffer ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createBufferView( const VULKAN_HPP_NAMESPACE::BufferViewCreateInfo * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::BufferView * pView, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateBufferView( m_device, |
| reinterpret_cast<const VkBufferViewCreateInfo *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkBufferView *>( pView ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::BufferView>::type |
| Device::createBufferView( const VULKAN_HPP_NAMESPACE::BufferViewCreateInfo & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateBufferView && "Function <vkCreateBufferView> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::BufferView view; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateBufferView( m_device, |
| reinterpret_cast<const VkBufferViewCreateInfo *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkBufferView *>( &view ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createBufferView" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( view ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::BufferView, Dispatch>>::type |
| Device::createBufferViewUnique( const VULKAN_HPP_NAMESPACE::BufferViewCreateInfo & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateBufferView && "Function <vkCreateBufferView> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::BufferView view; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateBufferView( m_device, |
| reinterpret_cast<const VkBufferViewCreateInfo *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkBufferView *>( &view ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createBufferViewUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::BufferView, Dispatch>( view, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyBufferView( VULKAN_HPP_NAMESPACE::BufferView bufferView, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyBufferView( m_device, static_cast<VkBufferView>( bufferView ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyBufferView( VULKAN_HPP_NAMESPACE::BufferView bufferView, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyBufferView && "Function <vkDestroyBufferView> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| d.vkDestroyBufferView( m_device, |
| static_cast<VkBufferView>( bufferView ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::BufferView bufferView, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyBufferView( m_device, static_cast<VkBufferView>( bufferView ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::BufferView bufferView, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyBufferView && "Function <vkDestroyBufferView> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| d.vkDestroyBufferView( m_device, |
| static_cast<VkBufferView>( bufferView ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createImage( const VULKAN_HPP_NAMESPACE::ImageCreateInfo * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::Image * pImage, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateImage( m_device, |
| reinterpret_cast<const VkImageCreateInfo *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkImage *>( pImage ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::Image>::type Device::createImage( |
| const VULKAN_HPP_NAMESPACE::ImageCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateImage && "Function <vkCreateImage> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Image image; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateImage( m_device, |
| reinterpret_cast<const VkImageCreateInfo *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkImage *>( &image ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createImage" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( image ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Image, Dispatch>>::type Device::createImageUnique( |
| const VULKAN_HPP_NAMESPACE::ImageCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateImage && "Function <vkCreateImage> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Image image; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateImage( m_device, |
| reinterpret_cast<const VkImageCreateInfo *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkImage *>( &image ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createImageUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::Image, Dispatch>( image, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyImage( VULKAN_HPP_NAMESPACE::Image image, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyImage( m_device, static_cast<VkImage>( image ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyImage( VULKAN_HPP_NAMESPACE::Image image, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyImage && "Function <vkDestroyImage> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| d.vkDestroyImage( m_device, |
| static_cast<VkImage>( image ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Image image, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyImage( m_device, static_cast<VkImage>( image ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Image image, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyImage && "Function <vkDestroyImage> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| d.vkDestroyImage( m_device, |
| static_cast<VkImage>( image ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::getImageSubresourceLayout( VULKAN_HPP_NAMESPACE::Image image, |
| const VULKAN_HPP_NAMESPACE::ImageSubresource * pSubresource, |
| VULKAN_HPP_NAMESPACE::SubresourceLayout * pLayout, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetImageSubresourceLayout( m_device, |
| static_cast<VkImage>( image ), |
| reinterpret_cast<const VkImageSubresource *>( pSubresource ), |
| reinterpret_cast<VkSubresourceLayout *>( pLayout ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::SubresourceLayout Device::getImageSubresourceLayout( |
| VULKAN_HPP_NAMESPACE::Image image, const VULKAN_HPP_NAMESPACE::ImageSubresource & subresource, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetImageSubresourceLayout && "Function <vkGetImageSubresourceLayout> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::SubresourceLayout layout; |
| d.vkGetImageSubresourceLayout( m_device, |
| static_cast<VkImage>( image ), |
| reinterpret_cast<const VkImageSubresource *>( &subresource ), |
| reinterpret_cast<VkSubresourceLayout *>( &layout ) ); |
| |
| return layout; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createImageView( const VULKAN_HPP_NAMESPACE::ImageViewCreateInfo * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::ImageView * pView, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateImageView( m_device, |
| reinterpret_cast<const VkImageViewCreateInfo *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkImageView *>( pView ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageView>::type |
| Device::createImageView( const VULKAN_HPP_NAMESPACE::ImageViewCreateInfo & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateImageView && "Function <vkCreateImageView> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::ImageView view; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateImageView( m_device, |
| reinterpret_cast<const VkImageViewCreateInfo *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkImageView *>( &view ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createImageView" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( view ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ImageView, Dispatch>>::type |
| Device::createImageViewUnique( const VULKAN_HPP_NAMESPACE::ImageViewCreateInfo & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateImageView && "Function <vkCreateImageView> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::ImageView view; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateImageView( m_device, |
| reinterpret_cast<const VkImageViewCreateInfo *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkImageView *>( &view ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createImageViewUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::ImageView, Dispatch>( view, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyImageView( VULKAN_HPP_NAMESPACE::ImageView imageView, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyImageView( m_device, static_cast<VkImageView>( imageView ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyImageView( VULKAN_HPP_NAMESPACE::ImageView imageView, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyImageView && "Function <vkDestroyImageView> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| d.vkDestroyImageView( m_device, |
| static_cast<VkImageView>( imageView ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::ImageView imageView, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyImageView( m_device, static_cast<VkImageView>( imageView ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::ImageView imageView, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyImageView && "Function <vkDestroyImageView> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| d.vkDestroyImageView( m_device, |
| static_cast<VkImageView>( imageView ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createShaderModule( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::ShaderModule * pShaderModule, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateShaderModule( m_device, |
| reinterpret_cast<const VkShaderModuleCreateInfo *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkShaderModule *>( pShaderModule ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::ShaderModule>::type |
| Device::createShaderModule( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateShaderModule && "Function <vkCreateShaderModule> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::ShaderModule shaderModule; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateShaderModule( m_device, |
| reinterpret_cast<const VkShaderModuleCreateInfo *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkShaderModule *>( &shaderModule ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createShaderModule" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( shaderModule ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderModule, Dispatch>>::type |
| Device::createShaderModuleUnique( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateShaderModule && "Function <vkCreateShaderModule> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::ShaderModule shaderModule; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateShaderModule( m_device, |
| reinterpret_cast<const VkShaderModuleCreateInfo *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkShaderModule *>( &shaderModule ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createShaderModuleUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderModule, Dispatch>( shaderModule, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyShaderModule( VULKAN_HPP_NAMESPACE::ShaderModule shaderModule, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyShaderModule( m_device, static_cast<VkShaderModule>( shaderModule ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyShaderModule( VULKAN_HPP_NAMESPACE::ShaderModule shaderModule, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyShaderModule && "Function <vkDestroyShaderModule> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| d.vkDestroyShaderModule( m_device, |
| static_cast<VkShaderModule>( shaderModule ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::ShaderModule shaderModule, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyShaderModule( m_device, static_cast<VkShaderModule>( shaderModule ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::ShaderModule shaderModule, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyShaderModule && "Function <vkDestroyShaderModule> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| d.vkDestroyShaderModule( m_device, |
| static_cast<VkShaderModule>( shaderModule ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createPipelineCache( const VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::PipelineCache * pPipelineCache, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreatePipelineCache( m_device, |
| reinterpret_cast<const VkPipelineCacheCreateInfo *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkPipelineCache *>( pPipelineCache ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::PipelineCache>::type |
| Device::createPipelineCache( const VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreatePipelineCache && "Function <vkCreatePipelineCache> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreatePipelineCache( m_device, |
| reinterpret_cast<const VkPipelineCacheCreateInfo *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkPipelineCache *>( &pipelineCache ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineCache" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( pipelineCache ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineCache, Dispatch>>::type |
| Device::createPipelineCacheUnique( const VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreatePipelineCache && "Function <vkCreatePipelineCache> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreatePipelineCache( m_device, |
| reinterpret_cast<const VkPipelineCacheCreateInfo *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkPipelineCache *>( &pipelineCache ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineCacheUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineCache, Dispatch>( pipelineCache, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyPipelineCache( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyPipelineCache( m_device, static_cast<VkPipelineCache>( pipelineCache ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyPipelineCache( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyPipelineCache && "Function <vkDestroyPipelineCache> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| d.vkDestroyPipelineCache( m_device, |
| static_cast<VkPipelineCache>( pipelineCache ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyPipelineCache( m_device, static_cast<VkPipelineCache>( pipelineCache ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyPipelineCache && "Function <vkDestroyPipelineCache> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| d.vkDestroyPipelineCache( m_device, |
| static_cast<VkPipelineCache>( pipelineCache ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getPipelineCacheData( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, |
| size_t * pDataSize, |
| void * pData, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetPipelineCacheData( m_device, static_cast<VkPipelineCache>( pipelineCache ), pDataSize, pData ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Uint8_tAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type |
| Device::getPipelineCacheData( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPipelineCacheData && "Function <vkGetPipelineCacheData> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| std::vector<uint8_t, Uint8_tAllocator> data; |
| size_t dataSize; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = |
| static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPipelineCacheData( m_device, static_cast<VkPipelineCache>( pipelineCache ), &dataSize, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && dataSize ) |
| { |
| data.resize( dataSize ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetPipelineCacheData( m_device, static_cast<VkPipelineCache>( pipelineCache ), &dataSize, reinterpret_cast<void *>( data.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineCacheData" ); |
| VULKAN_HPP_ASSERT( dataSize <= data.size() ); |
| if ( dataSize < data.size() ) |
| { |
| data.resize( dataSize ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); |
| } |
| |
| template <typename Uint8_tAllocator, |
| typename Dispatch, |
| typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type |
| Device::getPipelineCacheData( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, Uint8_tAllocator & uint8_tAllocator, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPipelineCacheData && "Function <vkGetPipelineCacheData> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| std::vector<uint8_t, Uint8_tAllocator> data( uint8_tAllocator ); |
| size_t dataSize; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = |
| static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPipelineCacheData( m_device, static_cast<VkPipelineCache>( pipelineCache ), &dataSize, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && dataSize ) |
| { |
| data.resize( dataSize ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetPipelineCacheData( m_device, static_cast<VkPipelineCache>( pipelineCache ), &dataSize, reinterpret_cast<void *>( data.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineCacheData" ); |
| VULKAN_HPP_ASSERT( dataSize <= data.size() ); |
| if ( dataSize < data.size() ) |
| { |
| data.resize( dataSize ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::mergePipelineCaches( VULKAN_HPP_NAMESPACE::PipelineCache dstCache, |
| uint32_t srcCacheCount, |
| const VULKAN_HPP_NAMESPACE::PipelineCache * pSrcCaches, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( |
| d.vkMergePipelineCaches( m_device, static_cast<VkPipelineCache>( dstCache ), srcCacheCount, reinterpret_cast<const VkPipelineCache *>( pSrcCaches ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type |
| Device::mergePipelineCaches( VULKAN_HPP_NAMESPACE::PipelineCache dstCache, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::PipelineCache> const & srcCaches, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkMergePipelineCaches && "Function <vkMergePipelineCaches> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkMergePipelineCaches( |
| m_device, static_cast<VkPipelineCache>( dstCache ), srcCaches.size(), reinterpret_cast<const VkPipelineCache *>( srcCaches.data() ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::mergePipelineCaches" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createGraphicsPipelines( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, |
| uint32_t createInfoCount, |
| const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo * pCreateInfos, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::Pipeline * pPipelines, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateGraphicsPipelines( m_device, |
| static_cast<VkPipelineCache>( pipelineCache ), |
| createInfoCount, |
| reinterpret_cast<const VkGraphicsPipelineCreateInfo *>( pCreateInfos ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkPipeline *>( pPipelines ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename PipelineAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>> |
| Device::createGraphicsPipelines( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateGraphicsPipelines && "Function <vkCreateGraphicsPipelines> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator> pipelines( createInfos.size() ); |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateGraphicsPipelines( |
| m_device, |
| static_cast<VkPipelineCache>( pipelineCache ), |
| createInfos.size(), |
| reinterpret_cast<const VkGraphicsPipelineCreateInfo *>( createInfos.data() ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkPipeline *>( pipelines.data() ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelines", |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); |
| |
| return ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>( result, std::move( pipelines ) ); |
| } |
| |
| template <typename PipelineAllocator, |
| typename Dispatch, |
| typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, VULKAN_HPP_NAMESPACE::Pipeline>::value, int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>> |
| Device::createGraphicsPipelines( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| PipelineAllocator & pipelineAllocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateGraphicsPipelines && "Function <vkCreateGraphicsPipelines> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator> pipelines( createInfos.size(), pipelineAllocator ); |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateGraphicsPipelines( |
| m_device, |
| static_cast<VkPipelineCache>( pipelineCache ), |
| createInfos.size(), |
| reinterpret_cast<const VkGraphicsPipelineCreateInfo *>( createInfos.data() ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkPipeline *>( pipelines.data() ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelines", |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); |
| |
| return ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>( result, std::move( pipelines ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<VULKAN_HPP_NAMESPACE::Pipeline> |
| Device::createGraphicsPipeline( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, |
| const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateGraphicsPipelines && "Function <vkCreateGraphicsPipelines> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Pipeline pipeline; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateGraphicsPipelines( |
| m_device, |
| static_cast<VkPipelineCache>( pipelineCache ), |
| 1, |
| reinterpret_cast<const VkGraphicsPipelineCreateInfo *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkPipeline *>( &pipeline ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipeline", |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); |
| |
| return ResultValue<VULKAN_HPP_NAMESPACE::Pipeline>( result, std::move( pipeline ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch, typename PipelineAllocator> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>> |
| Device::createGraphicsPipelinesUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateGraphicsPipelines && "Function <vkCreateGraphicsPipelines> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::Pipeline> pipelines( createInfos.size() ); |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateGraphicsPipelines( |
| m_device, |
| static_cast<VkPipelineCache>( pipelineCache ), |
| createInfos.size(), |
| reinterpret_cast<const VkGraphicsPipelineCreateInfo *>( createInfos.data() ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkPipeline *>( pipelines.data() ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelinesUnique", |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); |
| std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator> uniquePipelines; |
| uniquePipelines.reserve( createInfos.size() ); |
| ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d ); |
| for ( auto const & pipeline : pipelines ) |
| { |
| uniquePipelines.push_back( UniqueHandle<Pipeline, Dispatch>( pipeline, deleter ) ); |
| } |
| return ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>( result, std::move( uniquePipelines ) ); |
| } |
| |
| template < |
| typename Dispatch, |
| typename PipelineAllocator, |
| typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>::value, int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>> |
| Device::createGraphicsPipelinesUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| PipelineAllocator & pipelineAllocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateGraphicsPipelines && "Function <vkCreateGraphicsPipelines> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::Pipeline> pipelines( createInfos.size() ); |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateGraphicsPipelines( |
| m_device, |
| static_cast<VkPipelineCache>( pipelineCache ), |
| createInfos.size(), |
| reinterpret_cast<const VkGraphicsPipelineCreateInfo *>( createInfos.data() ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkPipeline *>( pipelines.data() ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelinesUnique", |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); |
| std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator> uniquePipelines( pipelineAllocator ); |
| uniquePipelines.reserve( createInfos.size() ); |
| ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d ); |
| for ( auto const & pipeline : pipelines ) |
| { |
| uniquePipelines.push_back( UniqueHandle<Pipeline, Dispatch>( pipeline, deleter ) ); |
| } |
| return ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>( result, std::move( uniquePipelines ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>> |
| Device::createGraphicsPipelineUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, |
| const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateGraphicsPipelines && "Function <vkCreateGraphicsPipelines> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Pipeline pipeline; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateGraphicsPipelines( |
| m_device, |
| static_cast<VkPipelineCache>( pipelineCache ), |
| 1, |
| reinterpret_cast<const VkGraphicsPipelineCreateInfo *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkPipeline *>( &pipeline ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelineUnique", |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); |
| |
| return ResultValue<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>( pipeline, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createComputePipelines( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, |
| uint32_t createInfoCount, |
| const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo * pCreateInfos, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::Pipeline * pPipelines, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateComputePipelines( m_device, |
| static_cast<VkPipelineCache>( pipelineCache ), |
| createInfoCount, |
| reinterpret_cast<const VkComputePipelineCreateInfo *>( pCreateInfos ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkPipeline *>( pPipelines ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename PipelineAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>> |
| Device::createComputePipelines( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateComputePipelines && "Function <vkCreateComputePipelines> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator> pipelines( createInfos.size() ); |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateComputePipelines( |
| m_device, |
| static_cast<VkPipelineCache>( pipelineCache ), |
| createInfos.size(), |
| reinterpret_cast<const VkComputePipelineCreateInfo *>( createInfos.data() ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkPipeline *>( pipelines.data() ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelines", |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); |
| |
| return ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>( result, std::move( pipelines ) ); |
| } |
| |
| template <typename PipelineAllocator, |
| typename Dispatch, |
| typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, VULKAN_HPP_NAMESPACE::Pipeline>::value, int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>> |
| Device::createComputePipelines( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| PipelineAllocator & pipelineAllocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateComputePipelines && "Function <vkCreateComputePipelines> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator> pipelines( createInfos.size(), pipelineAllocator ); |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateComputePipelines( |
| m_device, |
| static_cast<VkPipelineCache>( pipelineCache ), |
| createInfos.size(), |
| reinterpret_cast<const VkComputePipelineCreateInfo *>( createInfos.data() ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkPipeline *>( pipelines.data() ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelines", |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); |
| |
| return ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>( result, std::move( pipelines ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<VULKAN_HPP_NAMESPACE::Pipeline> |
| Device::createComputePipeline( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, |
| const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateComputePipelines && "Function <vkCreateComputePipelines> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Pipeline pipeline; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateComputePipelines( |
| m_device, |
| static_cast<VkPipelineCache>( pipelineCache ), |
| 1, |
| reinterpret_cast<const VkComputePipelineCreateInfo *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkPipeline *>( &pipeline ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipeline", |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); |
| |
| return ResultValue<VULKAN_HPP_NAMESPACE::Pipeline>( result, std::move( pipeline ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch, typename PipelineAllocator> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>> |
| Device::createComputePipelinesUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateComputePipelines && "Function <vkCreateComputePipelines> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::Pipeline> pipelines( createInfos.size() ); |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateComputePipelines( |
| m_device, |
| static_cast<VkPipelineCache>( pipelineCache ), |
| createInfos.size(), |
| reinterpret_cast<const VkComputePipelineCreateInfo *>( createInfos.data() ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkPipeline *>( pipelines.data() ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelinesUnique", |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); |
| std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator> uniquePipelines; |
| uniquePipelines.reserve( createInfos.size() ); |
| ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d ); |
| for ( auto const & pipeline : pipelines ) |
| { |
| uniquePipelines.push_back( UniqueHandle<Pipeline, Dispatch>( pipeline, deleter ) ); |
| } |
| return ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>( result, std::move( uniquePipelines ) ); |
| } |
| |
| template < |
| typename Dispatch, |
| typename PipelineAllocator, |
| typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>::value, int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>> |
| Device::createComputePipelinesUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| PipelineAllocator & pipelineAllocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateComputePipelines && "Function <vkCreateComputePipelines> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::Pipeline> pipelines( createInfos.size() ); |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateComputePipelines( |
| m_device, |
| static_cast<VkPipelineCache>( pipelineCache ), |
| createInfos.size(), |
| reinterpret_cast<const VkComputePipelineCreateInfo *>( createInfos.data() ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkPipeline *>( pipelines.data() ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelinesUnique", |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); |
| std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator> uniquePipelines( pipelineAllocator ); |
| uniquePipelines.reserve( createInfos.size() ); |
| ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d ); |
| for ( auto const & pipeline : pipelines ) |
| { |
| uniquePipelines.push_back( UniqueHandle<Pipeline, Dispatch>( pipeline, deleter ) ); |
| } |
| return ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>( result, std::move( uniquePipelines ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>> |
| Device::createComputePipelineUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, |
| const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateComputePipelines && "Function <vkCreateComputePipelines> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Pipeline pipeline; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateComputePipelines( |
| m_device, |
| static_cast<VkPipelineCache>( pipelineCache ), |
| 1, |
| reinterpret_cast<const VkComputePipelineCreateInfo *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkPipeline *>( &pipeline ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelineUnique", |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); |
| |
| return ResultValue<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>( pipeline, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyPipeline( VULKAN_HPP_NAMESPACE::Pipeline pipeline, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyPipeline( m_device, static_cast<VkPipeline>( pipeline ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyPipeline( VULKAN_HPP_NAMESPACE::Pipeline pipeline, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyPipeline && "Function <vkDestroyPipeline> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| d.vkDestroyPipeline( m_device, |
| static_cast<VkPipeline>( pipeline ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Pipeline pipeline, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyPipeline( m_device, static_cast<VkPipeline>( pipeline ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Pipeline pipeline, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyPipeline && "Function <vkDestroyPipeline> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| d.vkDestroyPipeline( m_device, |
| static_cast<VkPipeline>( pipeline ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createPipelineLayout( const VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::PipelineLayout * pPipelineLayout, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreatePipelineLayout( m_device, |
| reinterpret_cast<const VkPipelineLayoutCreateInfo *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkPipelineLayout *>( pPipelineLayout ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::PipelineLayout>::type |
| Device::createPipelineLayout( const VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreatePipelineLayout && "Function <vkCreatePipelineLayout> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreatePipelineLayout( m_device, |
| reinterpret_cast<const VkPipelineLayoutCreateInfo *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkPipelineLayout *>( &pipelineLayout ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineLayout" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( pipelineLayout ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineLayout, Dispatch>>::type |
| Device::createPipelineLayoutUnique( const VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreatePipelineLayout && "Function <vkCreatePipelineLayout> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreatePipelineLayout( m_device, |
| reinterpret_cast<const VkPipelineLayoutCreateInfo *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkPipelineLayout *>( &pipelineLayout ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineLayoutUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineLayout, Dispatch>( pipelineLayout, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyPipelineLayout( VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyPipelineLayout( m_device, static_cast<VkPipelineLayout>( pipelineLayout ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyPipelineLayout( VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyPipelineLayout && "Function <vkDestroyPipelineLayout> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| d.vkDestroyPipelineLayout( m_device, |
| static_cast<VkPipelineLayout>( pipelineLayout ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyPipelineLayout( m_device, static_cast<VkPipelineLayout>( pipelineLayout ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyPipelineLayout && "Function <vkDestroyPipelineLayout> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| d.vkDestroyPipelineLayout( m_device, |
| static_cast<VkPipelineLayout>( pipelineLayout ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createSampler( const VULKAN_HPP_NAMESPACE::SamplerCreateInfo * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::Sampler * pSampler, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateSampler( m_device, |
| reinterpret_cast<const VkSamplerCreateInfo *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkSampler *>( pSampler ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::Sampler>::type Device::createSampler( |
| const VULKAN_HPP_NAMESPACE::SamplerCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateSampler && "Function <vkCreateSampler> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Sampler sampler; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateSampler( m_device, |
| reinterpret_cast<const VkSamplerCreateInfo *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkSampler *>( &sampler ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSampler" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( sampler ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Sampler, Dispatch>>::type Device::createSamplerUnique( |
| const VULKAN_HPP_NAMESPACE::SamplerCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateSampler && "Function <vkCreateSampler> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Sampler sampler; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateSampler( m_device, |
| reinterpret_cast<const VkSamplerCreateInfo *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkSampler *>( &sampler ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSamplerUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::Sampler, Dispatch>( sampler, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroySampler( VULKAN_HPP_NAMESPACE::Sampler sampler, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroySampler( m_device, static_cast<VkSampler>( sampler ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroySampler( VULKAN_HPP_NAMESPACE::Sampler sampler, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroySampler && "Function <vkDestroySampler> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| d.vkDestroySampler( m_device, |
| static_cast<VkSampler>( sampler ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Sampler sampler, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroySampler( m_device, static_cast<VkSampler>( sampler ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Sampler sampler, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroySampler && "Function <vkDestroySampler> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| d.vkDestroySampler( m_device, |
| static_cast<VkSampler>( sampler ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createDescriptorSetLayout( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::DescriptorSetLayout * pSetLayout, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateDescriptorSetLayout( m_device, |
| reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkDescriptorSetLayout *>( pSetLayout ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::DescriptorSetLayout>::type |
| Device::createDescriptorSetLayout( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateDescriptorSetLayout && "Function <vkCreateDescriptorSetLayout> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::DescriptorSetLayout setLayout; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateDescriptorSetLayout( |
| m_device, |
| reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkDescriptorSetLayout *>( &setLayout ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorSetLayout" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( setLayout ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSetLayout, Dispatch>>::type |
| Device::createDescriptorSetLayoutUnique( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateDescriptorSetLayout && "Function <vkCreateDescriptorSetLayout> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::DescriptorSetLayout setLayout; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateDescriptorSetLayout( |
| m_device, |
| reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkDescriptorSetLayout *>( &setLayout ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorSetLayoutUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSetLayout, Dispatch>( setLayout, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyDescriptorSetLayout( VULKAN_HPP_NAMESPACE::DescriptorSetLayout descriptorSetLayout, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyDescriptorSetLayout( |
| m_device, static_cast<VkDescriptorSetLayout>( descriptorSetLayout ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyDescriptorSetLayout( VULKAN_HPP_NAMESPACE::DescriptorSetLayout descriptorSetLayout, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyDescriptorSetLayout && "Function <vkDestroyDescriptorSetLayout> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| d.vkDestroyDescriptorSetLayout( |
| m_device, |
| static_cast<VkDescriptorSetLayout>( descriptorSetLayout ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::DescriptorSetLayout descriptorSetLayout, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyDescriptorSetLayout( |
| m_device, static_cast<VkDescriptorSetLayout>( descriptorSetLayout ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::DescriptorSetLayout descriptorSetLayout, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyDescriptorSetLayout && "Function <vkDestroyDescriptorSetLayout> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| d.vkDestroyDescriptorSetLayout( |
| m_device, |
| static_cast<VkDescriptorSetLayout>( descriptorSetLayout ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createDescriptorPool( const VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::DescriptorPool * pDescriptorPool, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateDescriptorPool( m_device, |
| reinterpret_cast<const VkDescriptorPoolCreateInfo *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkDescriptorPool *>( pDescriptorPool ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::DescriptorPool>::type |
| Device::createDescriptorPool( const VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateDescriptorPool && "Function <vkCreateDescriptorPool> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateDescriptorPool( m_device, |
| reinterpret_cast<const VkDescriptorPoolCreateInfo *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkDescriptorPool *>( &descriptorPool ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorPool" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( descriptorPool ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorPool, Dispatch>>::type |
| Device::createDescriptorPoolUnique( const VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateDescriptorPool && "Function <vkCreateDescriptorPool> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateDescriptorPool( m_device, |
| reinterpret_cast<const VkDescriptorPoolCreateInfo *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkDescriptorPool *>( &descriptorPool ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorPoolUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorPool, Dispatch>( descriptorPool, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyDescriptorPool( m_device, static_cast<VkDescriptorPool>( descriptorPool ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyDescriptorPool && "Function <vkDestroyDescriptorPool> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| d.vkDestroyDescriptorPool( m_device, |
| static_cast<VkDescriptorPool>( descriptorPool ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyDescriptorPool( m_device, static_cast<VkDescriptorPool>( descriptorPool ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyDescriptorPool && "Function <vkDestroyDescriptorPool> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| d.vkDestroyDescriptorPool( m_device, |
| static_cast<VkDescriptorPool>( descriptorPool ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE Result Device::resetDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, |
| VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlags flags, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( |
| d.vkResetDescriptorPool( m_device, static_cast<VkDescriptorPool>( descriptorPool ), static_cast<VkDescriptorPoolResetFlags>( flags ) ) ); |
| } |
| #else |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::resetDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, |
| VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlags flags, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkResetDescriptorPool && "Function <vkResetDescriptorPool> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| d.vkResetDescriptorPool( m_device, static_cast<VkDescriptorPool>( descriptorPool ), static_cast<VkDescriptorPoolResetFlags>( flags ) ); |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::allocateDescriptorSets( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo * pAllocateInfo, |
| VULKAN_HPP_NAMESPACE::DescriptorSet * pDescriptorSets, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkAllocateDescriptorSets( |
| m_device, reinterpret_cast<const VkDescriptorSetAllocateInfo *>( pAllocateInfo ), reinterpret_cast<VkDescriptorSet *>( pDescriptorSets ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename DescriptorSetAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DescriptorSet, DescriptorSetAllocator>>::type |
| Device::allocateDescriptorSets( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo & allocateInfo, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkAllocateDescriptorSets && "Function <vkAllocateDescriptorSets> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::DescriptorSet, DescriptorSetAllocator> descriptorSets( allocateInfo.descriptorSetCount ); |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkAllocateDescriptorSets( |
| m_device, reinterpret_cast<const VkDescriptorSetAllocateInfo *>( &allocateInfo ), reinterpret_cast<VkDescriptorSet *>( descriptorSets.data() ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSets" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( descriptorSets ) ); |
| } |
| |
| template <typename DescriptorSetAllocator, |
| typename Dispatch, |
| typename std::enable_if<std::is_same<typename DescriptorSetAllocator::value_type, VULKAN_HPP_NAMESPACE::DescriptorSet>::value, int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DescriptorSet, DescriptorSetAllocator>>::type |
| Device::allocateDescriptorSets( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo & allocateInfo, |
| DescriptorSetAllocator & descriptorSetAllocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkAllocateDescriptorSets && "Function <vkAllocateDescriptorSets> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::DescriptorSet, DescriptorSetAllocator> descriptorSets( allocateInfo.descriptorSetCount, descriptorSetAllocator ); |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkAllocateDescriptorSets( |
| m_device, reinterpret_cast<const VkDescriptorSetAllocateInfo *>( &allocateInfo ), reinterpret_cast<VkDescriptorSet *>( descriptorSets.data() ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSets" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( descriptorSets ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch, typename DescriptorSetAllocator> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE |
| typename ResultValueType<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSet, Dispatch>, DescriptorSetAllocator>>::type |
| Device::allocateDescriptorSetsUnique( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo & allocateInfo, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkAllocateDescriptorSets && "Function <vkAllocateDescriptorSets> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::DescriptorSet> descriptorSets( allocateInfo.descriptorSetCount ); |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkAllocateDescriptorSets( |
| m_device, reinterpret_cast<const VkDescriptorSetAllocateInfo *>( &allocateInfo ), reinterpret_cast<VkDescriptorSet *>( descriptorSets.data() ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSetsUnique" ); |
| std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSet, Dispatch>, DescriptorSetAllocator> uniqueDescriptorSets; |
| uniqueDescriptorSets.reserve( allocateInfo.descriptorSetCount ); |
| PoolFree<Device, DescriptorPool, Dispatch> deleter( *this, allocateInfo.descriptorPool, d ); |
| for ( auto const & descriptorSet : descriptorSets ) |
| { |
| uniqueDescriptorSets.push_back( UniqueHandle<DescriptorSet, Dispatch>( descriptorSet, deleter ) ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( uniqueDescriptorSets ) ); |
| } |
| |
| template < |
| typename Dispatch, |
| typename DescriptorSetAllocator, |
| typename std::enable_if<std::is_same<typename DescriptorSetAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSet, Dispatch>>::value, |
| int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE |
| typename ResultValueType<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSet, Dispatch>, DescriptorSetAllocator>>::type |
| Device::allocateDescriptorSetsUnique( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo & allocateInfo, |
| DescriptorSetAllocator & descriptorSetAllocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkAllocateDescriptorSets && "Function <vkAllocateDescriptorSets> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::DescriptorSet> descriptorSets( allocateInfo.descriptorSetCount ); |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkAllocateDescriptorSets( |
| m_device, reinterpret_cast<const VkDescriptorSetAllocateInfo *>( &allocateInfo ), reinterpret_cast<VkDescriptorSet *>( descriptorSets.data() ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSetsUnique" ); |
| std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSet, Dispatch>, DescriptorSetAllocator> uniqueDescriptorSets( descriptorSetAllocator ); |
| uniqueDescriptorSets.reserve( allocateInfo.descriptorSetCount ); |
| PoolFree<Device, DescriptorPool, Dispatch> deleter( *this, allocateInfo.descriptorPool, d ); |
| for ( auto const & descriptorSet : descriptorSets ) |
| { |
| uniqueDescriptorSets.push_back( UniqueHandle<DescriptorSet, Dispatch>( descriptorSet, deleter ) ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( uniqueDescriptorSets ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE Result Device::freeDescriptorSets( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, |
| uint32_t descriptorSetCount, |
| const VULKAN_HPP_NAMESPACE::DescriptorSet * pDescriptorSets, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkFreeDescriptorSets( |
| m_device, static_cast<VkDescriptorPool>( descriptorPool ), descriptorSetCount, reinterpret_cast<const VkDescriptorSet *>( pDescriptorSets ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::freeDescriptorSets( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const & descriptorSets, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkFreeDescriptorSets && "Function <vkFreeDescriptorSets> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| d.vkFreeDescriptorSets( |
| m_device, static_cast<VkDescriptorPool>( descriptorPool ), descriptorSets.size(), reinterpret_cast<const VkDescriptorSet *>( descriptorSets.data() ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE Result( Device::free )( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, |
| uint32_t descriptorSetCount, |
| const VULKAN_HPP_NAMESPACE::DescriptorSet * pDescriptorSets, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkFreeDescriptorSets( |
| m_device, static_cast<VkDescriptorPool>( descriptorPool ), descriptorSetCount, reinterpret_cast<const VkDescriptorSet *>( pDescriptorSets ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void( Device::free )( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const & descriptorSets, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkFreeDescriptorSets && "Function <vkFreeDescriptorSets> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| d.vkFreeDescriptorSets( |
| m_device, static_cast<VkDescriptorPool>( descriptorPool ), descriptorSets.size(), reinterpret_cast<const VkDescriptorSet *>( descriptorSets.data() ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::updateDescriptorSets( uint32_t descriptorWriteCount, |
| const VULKAN_HPP_NAMESPACE::WriteDescriptorSet * pDescriptorWrites, |
| uint32_t descriptorCopyCount, |
| const VULKAN_HPP_NAMESPACE::CopyDescriptorSet * pDescriptorCopies, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkUpdateDescriptorSets( m_device, |
| descriptorWriteCount, |
| reinterpret_cast<const VkWriteDescriptorSet *>( pDescriptorWrites ), |
| descriptorCopyCount, |
| reinterpret_cast<const VkCopyDescriptorSet *>( pDescriptorCopies ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void |
| Device::updateDescriptorSets( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CopyDescriptorSet> const & descriptorCopies, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkUpdateDescriptorSets && "Function <vkUpdateDescriptorSets> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| d.vkUpdateDescriptorSets( m_device, |
| descriptorWrites.size(), |
| reinterpret_cast<const VkWriteDescriptorSet *>( descriptorWrites.data() ), |
| descriptorCopies.size(), |
| reinterpret_cast<const VkCopyDescriptorSet *>( descriptorCopies.data() ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createFramebuffer( const VULKAN_HPP_NAMESPACE::FramebufferCreateInfo * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::Framebuffer * pFramebuffer, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateFramebuffer( m_device, |
| reinterpret_cast<const VkFramebufferCreateInfo *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkFramebuffer *>( pFramebuffer ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::Framebuffer>::type |
| Device::createFramebuffer( const VULKAN_HPP_NAMESPACE::FramebufferCreateInfo & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateFramebuffer && "Function <vkCreateFramebuffer> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Framebuffer framebuffer; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateFramebuffer( m_device, |
| reinterpret_cast<const VkFramebufferCreateInfo *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkFramebuffer *>( &framebuffer ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createFramebuffer" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( framebuffer ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Framebuffer, Dispatch>>::type |
| Device::createFramebufferUnique( const VULKAN_HPP_NAMESPACE::FramebufferCreateInfo & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateFramebuffer && "Function <vkCreateFramebuffer> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Framebuffer framebuffer; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateFramebuffer( m_device, |
| reinterpret_cast<const VkFramebufferCreateInfo *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkFramebuffer *>( &framebuffer ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createFramebufferUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::Framebuffer, Dispatch>( framebuffer, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyFramebuffer( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyFramebuffer( m_device, static_cast<VkFramebuffer>( framebuffer ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyFramebuffer( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyFramebuffer && "Function <vkDestroyFramebuffer> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| d.vkDestroyFramebuffer( m_device, |
| static_cast<VkFramebuffer>( framebuffer ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyFramebuffer( m_device, static_cast<VkFramebuffer>( framebuffer ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyFramebuffer && "Function <vkDestroyFramebuffer> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| d.vkDestroyFramebuffer( m_device, |
| static_cast<VkFramebuffer>( framebuffer ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::RenderPass * pRenderPass, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateRenderPass( m_device, |
| reinterpret_cast<const VkRenderPassCreateInfo *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkRenderPass *>( pRenderPass ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::RenderPass>::type |
| Device::createRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateRenderPass && "Function <vkCreateRenderPass> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::RenderPass renderPass; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateRenderPass( m_device, |
| reinterpret_cast<const VkRenderPassCreateInfo *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkRenderPass *>( &renderPass ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPass" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( renderPass ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>>::type |
| Device::createRenderPassUnique( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateRenderPass && "Function <vkCreateRenderPass> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::RenderPass renderPass; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateRenderPass( m_device, |
| reinterpret_cast<const VkRenderPassCreateInfo *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkRenderPass *>( &renderPass ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPassUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>( renderPass, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyRenderPass( VULKAN_HPP_NAMESPACE::RenderPass renderPass, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyRenderPass( m_device, static_cast<VkRenderPass>( renderPass ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyRenderPass( VULKAN_HPP_NAMESPACE::RenderPass renderPass, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyRenderPass && "Function <vkDestroyRenderPass> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| d.vkDestroyRenderPass( m_device, |
| static_cast<VkRenderPass>( renderPass ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::RenderPass renderPass, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyRenderPass( m_device, static_cast<VkRenderPass>( renderPass ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::RenderPass renderPass, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyRenderPass && "Function <vkDestroyRenderPass> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| d.vkDestroyRenderPass( m_device, |
| static_cast<VkRenderPass>( renderPass ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::getRenderAreaGranularity( VULKAN_HPP_NAMESPACE::RenderPass renderPass, |
| VULKAN_HPP_NAMESPACE::Extent2D * pGranularity, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetRenderAreaGranularity( m_device, static_cast<VkRenderPass>( renderPass ), reinterpret_cast<VkExtent2D *>( pGranularity ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Extent2D Device::getRenderAreaGranularity( VULKAN_HPP_NAMESPACE::RenderPass renderPass, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetRenderAreaGranularity && "Function <vkGetRenderAreaGranularity> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Extent2D granularity; |
| d.vkGetRenderAreaGranularity( m_device, static_cast<VkRenderPass>( renderPass ), reinterpret_cast<VkExtent2D *>( &granularity ) ); |
| |
| return granularity; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createCommandPool( const VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::CommandPool * pCommandPool, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateCommandPool( m_device, |
| reinterpret_cast<const VkCommandPoolCreateInfo *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkCommandPool *>( pCommandPool ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::CommandPool>::type |
| Device::createCommandPool( const VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateCommandPool && "Function <vkCreateCommandPool> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::CommandPool commandPool; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateCommandPool( m_device, |
| reinterpret_cast<const VkCommandPoolCreateInfo *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkCommandPool *>( &commandPool ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createCommandPool" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( commandPool ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandPool, Dispatch>>::type |
| Device::createCommandPoolUnique( const VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateCommandPool && "Function <vkCreateCommandPool> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::CommandPool commandPool; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateCommandPool( m_device, |
| reinterpret_cast<const VkCommandPoolCreateInfo *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkCommandPool *>( &commandPool ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createCommandPoolUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::CommandPool, Dispatch>( commandPool, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyCommandPool( VULKAN_HPP_NAMESPACE::CommandPool commandPool, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyCommandPool( VULKAN_HPP_NAMESPACE::CommandPool commandPool, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyCommandPool && "Function <vkDestroyCommandPool> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| d.vkDestroyCommandPool( m_device, |
| static_cast<VkCommandPool>( commandPool ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::CommandPool commandPool, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::CommandPool commandPool, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyCommandPool && "Function <vkDestroyCommandPool> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| d.vkDestroyCommandPool( m_device, |
| static_cast<VkCommandPool>( commandPool ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::resetCommandPool( VULKAN_HPP_NAMESPACE::CommandPool commandPool, |
| VULKAN_HPP_NAMESPACE::CommandPoolResetFlags flags, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkResetCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolResetFlags>( flags ) ) ); |
| } |
| #else |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE typename ResultValueType<void>::type |
| Device::resetCommandPool( VULKAN_HPP_NAMESPACE::CommandPool commandPool, VULKAN_HPP_NAMESPACE::CommandPoolResetFlags flags, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkResetCommandPool && "Function <vkResetCommandPool> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkResetCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolResetFlags>( flags ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::resetCommandPool" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::allocateCommandBuffers( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo * pAllocateInfo, |
| VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkAllocateCommandBuffers( |
| m_device, reinterpret_cast<const VkCommandBufferAllocateInfo *>( pAllocateInfo ), reinterpret_cast<VkCommandBuffer *>( pCommandBuffers ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename CommandBufferAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CommandBuffer, CommandBufferAllocator>>::type |
| Device::allocateCommandBuffers( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo & allocateInfo, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkAllocateCommandBuffers && "Function <vkAllocateCommandBuffers> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::CommandBuffer, CommandBufferAllocator> commandBuffers( allocateInfo.commandBufferCount ); |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkAllocateCommandBuffers( |
| m_device, reinterpret_cast<const VkCommandBufferAllocateInfo *>( &allocateInfo ), reinterpret_cast<VkCommandBuffer *>( commandBuffers.data() ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffers" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( commandBuffers ) ); |
| } |
| |
| template <typename CommandBufferAllocator, |
| typename Dispatch, |
| typename std::enable_if<std::is_same<typename CommandBufferAllocator::value_type, VULKAN_HPP_NAMESPACE::CommandBuffer>::value, int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CommandBuffer, CommandBufferAllocator>>::type |
| Device::allocateCommandBuffers( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo & allocateInfo, |
| CommandBufferAllocator & commandBufferAllocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkAllocateCommandBuffers && "Function <vkAllocateCommandBuffers> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::CommandBuffer, CommandBufferAllocator> commandBuffers( allocateInfo.commandBufferCount, commandBufferAllocator ); |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkAllocateCommandBuffers( |
| m_device, reinterpret_cast<const VkCommandBufferAllocateInfo *>( &allocateInfo ), reinterpret_cast<VkCommandBuffer *>( commandBuffers.data() ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffers" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( commandBuffers ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch, typename CommandBufferAllocator> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE |
| typename ResultValueType<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandBuffer, Dispatch>, CommandBufferAllocator>>::type |
| Device::allocateCommandBuffersUnique( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo & allocateInfo, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkAllocateCommandBuffers && "Function <vkAllocateCommandBuffers> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::CommandBuffer> commandBuffers( allocateInfo.commandBufferCount ); |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkAllocateCommandBuffers( |
| m_device, reinterpret_cast<const VkCommandBufferAllocateInfo *>( &allocateInfo ), reinterpret_cast<VkCommandBuffer *>( commandBuffers.data() ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffersUnique" ); |
| std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandBuffer, Dispatch>, CommandBufferAllocator> uniqueCommandBuffers; |
| uniqueCommandBuffers.reserve( allocateInfo.commandBufferCount ); |
| PoolFree<Device, CommandPool, Dispatch> deleter( *this, allocateInfo.commandPool, d ); |
| for ( auto const & commandBuffer : commandBuffers ) |
| { |
| uniqueCommandBuffers.push_back( UniqueHandle<CommandBuffer, Dispatch>( commandBuffer, deleter ) ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( uniqueCommandBuffers ) ); |
| } |
| |
| template < |
| typename Dispatch, |
| typename CommandBufferAllocator, |
| typename std::enable_if<std::is_same<typename CommandBufferAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::CommandBuffer, Dispatch>>::value, |
| int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE |
| typename ResultValueType<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandBuffer, Dispatch>, CommandBufferAllocator>>::type |
| Device::allocateCommandBuffersUnique( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo & allocateInfo, |
| CommandBufferAllocator & commandBufferAllocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkAllocateCommandBuffers && "Function <vkAllocateCommandBuffers> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::CommandBuffer> commandBuffers( allocateInfo.commandBufferCount ); |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkAllocateCommandBuffers( |
| m_device, reinterpret_cast<const VkCommandBufferAllocateInfo *>( &allocateInfo ), reinterpret_cast<VkCommandBuffer *>( commandBuffers.data() ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffersUnique" ); |
| std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandBuffer, Dispatch>, CommandBufferAllocator> uniqueCommandBuffers( commandBufferAllocator ); |
| uniqueCommandBuffers.reserve( allocateInfo.commandBufferCount ); |
| PoolFree<Device, CommandPool, Dispatch> deleter( *this, allocateInfo.commandPool, d ); |
| for ( auto const & commandBuffer : commandBuffers ) |
| { |
| uniqueCommandBuffers.push_back( UniqueHandle<CommandBuffer, Dispatch>( commandBuffer, deleter ) ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( uniqueCommandBuffers ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::freeCommandBuffers( VULKAN_HPP_NAMESPACE::CommandPool commandPool, |
| uint32_t commandBufferCount, |
| const VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkFreeCommandBuffers( |
| m_device, static_cast<VkCommandPool>( commandPool ), commandBufferCount, reinterpret_cast<const VkCommandBuffer *>( pCommandBuffers ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::freeCommandBuffers( VULKAN_HPP_NAMESPACE::CommandPool commandPool, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkFreeCommandBuffers && "Function <vkFreeCommandBuffers> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| d.vkFreeCommandBuffers( |
| m_device, static_cast<VkCommandPool>( commandPool ), commandBuffers.size(), reinterpret_cast<const VkCommandBuffer *>( commandBuffers.data() ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void( Device::free )( VULKAN_HPP_NAMESPACE::CommandPool commandPool, |
| uint32_t commandBufferCount, |
| const VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkFreeCommandBuffers( |
| m_device, static_cast<VkCommandPool>( commandPool ), commandBufferCount, reinterpret_cast<const VkCommandBuffer *>( pCommandBuffers ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void( Device::free )( VULKAN_HPP_NAMESPACE::CommandPool commandPool, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkFreeCommandBuffers && "Function <vkFreeCommandBuffers> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| d.vkFreeCommandBuffers( |
| m_device, static_cast<VkCommandPool>( commandPool ), commandBuffers.size(), reinterpret_cast<const VkCommandBuffer *>( commandBuffers.data() ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result CommandBuffer::begin( const VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo * pBeginInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkBeginCommandBuffer( m_commandBuffer, reinterpret_cast<const VkCommandBufferBeginInfo *>( pBeginInfo ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type |
| CommandBuffer::begin( const VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo & beginInfo, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkBeginCommandBuffer && "Function <vkBeginCommandBuffer> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = |
| static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkBeginCommandBuffer( m_commandBuffer, reinterpret_cast<const VkCommandBufferBeginInfo *>( &beginInfo ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::begin" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result CommandBuffer::end( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkEndCommandBuffer( m_commandBuffer ) ); |
| } |
| #else |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type CommandBuffer::end( Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkEndCommandBuffer && "Function <vkEndCommandBuffer> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkEndCommandBuffer( m_commandBuffer ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::end" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result CommandBuffer::reset( VULKAN_HPP_NAMESPACE::CommandBufferResetFlags flags, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkResetCommandBuffer( m_commandBuffer, static_cast<VkCommandBufferResetFlags>( flags ) ) ); |
| } |
| #else |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE typename ResultValueType<void>::type CommandBuffer::reset( VULKAN_HPP_NAMESPACE::CommandBufferResetFlags flags, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkResetCommandBuffer && "Function <vkResetCommandBuffer> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = |
| static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkResetCommandBuffer( m_commandBuffer, static_cast<VkCommandBufferResetFlags>( flags ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::reset" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::bindPipeline( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, |
| VULKAN_HPP_NAMESPACE::Pipeline pipeline, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdBindPipeline( m_commandBuffer, static_cast<VkPipelineBindPoint>( pipelineBindPoint ), static_cast<VkPipeline>( pipeline ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setViewport( uint32_t firstViewport, |
| uint32_t viewportCount, |
| const VULKAN_HPP_NAMESPACE::Viewport * pViewports, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetViewport( m_commandBuffer, firstViewport, viewportCount, reinterpret_cast<const VkViewport *>( pViewports ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setViewport( uint32_t firstViewport, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdSetViewport && "Function <vkCmdSetViewport> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| d.vkCmdSetViewport( m_commandBuffer, firstViewport, viewports.size(), reinterpret_cast<const VkViewport *>( viewports.data() ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setScissor( uint32_t firstScissor, |
| uint32_t scissorCount, |
| const VULKAN_HPP_NAMESPACE::Rect2D * pScissors, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetScissor( m_commandBuffer, firstScissor, scissorCount, reinterpret_cast<const VkRect2D *>( pScissors ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setScissor( uint32_t firstScissor, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdSetScissor && "Function <vkCmdSetScissor> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| d.vkCmdSetScissor( m_commandBuffer, firstScissor, scissors.size(), reinterpret_cast<const VkRect2D *>( scissors.data() ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setLineWidth( float lineWidth, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetLineWidth( m_commandBuffer, lineWidth ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void |
| CommandBuffer::setDepthBias( float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetDepthBias( m_commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setBlendConstants( const float blendConstants[4], Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetBlendConstants( m_commandBuffer, blendConstants ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setDepthBounds( float minDepthBounds, float maxDepthBounds, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetDepthBounds( m_commandBuffer, minDepthBounds, maxDepthBounds ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void |
| CommandBuffer::setStencilCompareMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, uint32_t compareMask, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetStencilCompareMask( m_commandBuffer, static_cast<VkStencilFaceFlags>( faceMask ), compareMask ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void |
| CommandBuffer::setStencilWriteMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, uint32_t writeMask, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetStencilWriteMask( m_commandBuffer, static_cast<VkStencilFaceFlags>( faceMask ), writeMask ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void |
| CommandBuffer::setStencilReference( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, uint32_t reference, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetStencilReference( m_commandBuffer, static_cast<VkStencilFaceFlags>( faceMask ), reference ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorSets( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, |
| VULKAN_HPP_NAMESPACE::PipelineLayout layout, |
| uint32_t firstSet, |
| uint32_t descriptorSetCount, |
| const VULKAN_HPP_NAMESPACE::DescriptorSet * pDescriptorSets, |
| uint32_t dynamicOffsetCount, |
| const uint32_t * pDynamicOffsets, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdBindDescriptorSets( m_commandBuffer, |
| static_cast<VkPipelineBindPoint>( pipelineBindPoint ), |
| static_cast<VkPipelineLayout>( layout ), |
| firstSet, |
| descriptorSetCount, |
| reinterpret_cast<const VkDescriptorSet *>( pDescriptorSets ), |
| dynamicOffsetCount, |
| pDynamicOffsets ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorSets( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, |
| VULKAN_HPP_NAMESPACE::PipelineLayout layout, |
| uint32_t firstSet, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const & descriptorSets, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t> const & dynamicOffsets, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdBindDescriptorSets && "Function <vkCmdBindDescriptorSets> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| d.vkCmdBindDescriptorSets( m_commandBuffer, |
| static_cast<VkPipelineBindPoint>( pipelineBindPoint ), |
| static_cast<VkPipelineLayout>( layout ), |
| firstSet, |
| descriptorSets.size(), |
| reinterpret_cast<const VkDescriptorSet *>( descriptorSets.data() ), |
| dynamicOffsets.size(), |
| dynamicOffsets.data() ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::bindIndexBuffer( VULKAN_HPP_NAMESPACE::Buffer buffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize offset, |
| VULKAN_HPP_NAMESPACE::IndexType indexType, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdBindIndexBuffer( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkIndexType>( indexType ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers( uint32_t firstBinding, |
| uint32_t bindingCount, |
| const VULKAN_HPP_NAMESPACE::Buffer * pBuffers, |
| const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdBindVertexBuffers( |
| m_commandBuffer, firstBinding, bindingCount, reinterpret_cast<const VkBuffer *>( pBuffers ), reinterpret_cast<const VkDeviceSize *>( pOffsets ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers( uint32_t firstBinding, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdBindVertexBuffers && "Function <vkCmdBindVertexBuffers> requires <VK_VERSION_1_0>" ); |
| # endif |
| # ifdef VULKAN_HPP_NO_EXCEPTIONS |
| VULKAN_HPP_ASSERT( buffers.size() == offsets.size() ); |
| # else |
| if ( buffers.size() != offsets.size() ) |
| { |
| throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers: buffers.size() != offsets.size()" ); |
| } |
| # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ |
| |
| d.vkCmdBindVertexBuffers( m_commandBuffer, |
| firstBinding, |
| buffers.size(), |
| reinterpret_cast<const VkBuffer *>( buffers.data() ), |
| reinterpret_cast<const VkDeviceSize *>( offsets.data() ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::draw( |
| uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdDraw( m_commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::drawIndexed( uint32_t indexCount, |
| uint32_t instanceCount, |
| uint32_t firstIndex, |
| int32_t vertexOffset, |
| uint32_t firstInstance, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdDrawIndexed( m_commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::drawIndirect( VULKAN_HPP_NAMESPACE::Buffer buffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize offset, |
| uint32_t drawCount, |
| uint32_t stride, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdDrawIndirect( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), drawCount, stride ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirect( VULKAN_HPP_NAMESPACE::Buffer buffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize offset, |
| uint32_t drawCount, |
| uint32_t stride, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdDrawIndexedIndirect( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), drawCount, stride ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void |
| CommandBuffer::dispatch( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdDispatch( m_commandBuffer, groupCountX, groupCountY, groupCountZ ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::dispatchIndirect( VULKAN_HPP_NAMESPACE::Buffer buffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize offset, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdDispatchIndirect( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::copyBuffer( VULKAN_HPP_NAMESPACE::Buffer srcBuffer, |
| VULKAN_HPP_NAMESPACE::Buffer dstBuffer, |
| uint32_t regionCount, |
| const VULKAN_HPP_NAMESPACE::BufferCopy * pRegions, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdCopyBuffer( m_commandBuffer, |
| static_cast<VkBuffer>( srcBuffer ), |
| static_cast<VkBuffer>( dstBuffer ), |
| regionCount, |
| reinterpret_cast<const VkBufferCopy *>( pRegions ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::copyBuffer( VULKAN_HPP_NAMESPACE::Buffer srcBuffer, |
| VULKAN_HPP_NAMESPACE::Buffer dstBuffer, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferCopy> const & regions, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdCopyBuffer && "Function <vkCmdCopyBuffer> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| d.vkCmdCopyBuffer( m_commandBuffer, |
| static_cast<VkBuffer>( srcBuffer ), |
| static_cast<VkBuffer>( dstBuffer ), |
| regions.size(), |
| reinterpret_cast<const VkBufferCopy *>( regions.data() ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::copyImage( VULKAN_HPP_NAMESPACE::Image srcImage, |
| VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, |
| VULKAN_HPP_NAMESPACE::Image dstImage, |
| VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, |
| uint32_t regionCount, |
| const VULKAN_HPP_NAMESPACE::ImageCopy * pRegions, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdCopyImage( m_commandBuffer, |
| static_cast<VkImage>( srcImage ), |
| static_cast<VkImageLayout>( srcImageLayout ), |
| static_cast<VkImage>( dstImage ), |
| static_cast<VkImageLayout>( dstImageLayout ), |
| regionCount, |
| reinterpret_cast<const VkImageCopy *>( pRegions ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::copyImage( VULKAN_HPP_NAMESPACE::Image srcImage, |
| VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, |
| VULKAN_HPP_NAMESPACE::Image dstImage, |
| VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageCopy> const & regions, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdCopyImage && "Function <vkCmdCopyImage> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| d.vkCmdCopyImage( m_commandBuffer, |
| static_cast<VkImage>( srcImage ), |
| static_cast<VkImageLayout>( srcImageLayout ), |
| static_cast<VkImage>( dstImage ), |
| static_cast<VkImageLayout>( dstImageLayout ), |
| regions.size(), |
| reinterpret_cast<const VkImageCopy *>( regions.data() ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::blitImage( VULKAN_HPP_NAMESPACE::Image srcImage, |
| VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, |
| VULKAN_HPP_NAMESPACE::Image dstImage, |
| VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, |
| uint32_t regionCount, |
| const VULKAN_HPP_NAMESPACE::ImageBlit * pRegions, |
| VULKAN_HPP_NAMESPACE::Filter filter, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdBlitImage( m_commandBuffer, |
| static_cast<VkImage>( srcImage ), |
| static_cast<VkImageLayout>( srcImageLayout ), |
| static_cast<VkImage>( dstImage ), |
| static_cast<VkImageLayout>( dstImageLayout ), |
| regionCount, |
| reinterpret_cast<const VkImageBlit *>( pRegions ), |
| static_cast<VkFilter>( filter ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::blitImage( VULKAN_HPP_NAMESPACE::Image srcImage, |
| VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, |
| VULKAN_HPP_NAMESPACE::Image dstImage, |
| VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageBlit> const & regions, |
| VULKAN_HPP_NAMESPACE::Filter filter, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdBlitImage && "Function <vkCmdBlitImage> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| d.vkCmdBlitImage( m_commandBuffer, |
| static_cast<VkImage>( srcImage ), |
| static_cast<VkImageLayout>( srcImageLayout ), |
| static_cast<VkImage>( dstImage ), |
| static_cast<VkImageLayout>( dstImageLayout ), |
| regions.size(), |
| reinterpret_cast<const VkImageBlit *>( regions.data() ), |
| static_cast<VkFilter>( filter ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage( VULKAN_HPP_NAMESPACE::Buffer srcBuffer, |
| VULKAN_HPP_NAMESPACE::Image dstImage, |
| VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, |
| uint32_t regionCount, |
| const VULKAN_HPP_NAMESPACE::BufferImageCopy * pRegions, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdCopyBufferToImage( m_commandBuffer, |
| static_cast<VkBuffer>( srcBuffer ), |
| static_cast<VkImage>( dstImage ), |
| static_cast<VkImageLayout>( dstImageLayout ), |
| regionCount, |
| reinterpret_cast<const VkBufferImageCopy *>( pRegions ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage( VULKAN_HPP_NAMESPACE::Buffer srcBuffer, |
| VULKAN_HPP_NAMESPACE::Image dstImage, |
| VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const & regions, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdCopyBufferToImage && "Function <vkCmdCopyBufferToImage> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| d.vkCmdCopyBufferToImage( m_commandBuffer, |
| static_cast<VkBuffer>( srcBuffer ), |
| static_cast<VkImage>( dstImage ), |
| static_cast<VkImageLayout>( dstImageLayout ), |
| regions.size(), |
| reinterpret_cast<const VkBufferImageCopy *>( regions.data() ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer( VULKAN_HPP_NAMESPACE::Image srcImage, |
| VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, |
| VULKAN_HPP_NAMESPACE::Buffer dstBuffer, |
| uint32_t regionCount, |
| const VULKAN_HPP_NAMESPACE::BufferImageCopy * pRegions, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdCopyImageToBuffer( m_commandBuffer, |
| static_cast<VkImage>( srcImage ), |
| static_cast<VkImageLayout>( srcImageLayout ), |
| static_cast<VkBuffer>( dstBuffer ), |
| regionCount, |
| reinterpret_cast<const VkBufferImageCopy *>( pRegions ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer( VULKAN_HPP_NAMESPACE::Image srcImage, |
| VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, |
| VULKAN_HPP_NAMESPACE::Buffer dstBuffer, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const & regions, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdCopyImageToBuffer && "Function <vkCmdCopyImageToBuffer> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| d.vkCmdCopyImageToBuffer( m_commandBuffer, |
| static_cast<VkImage>( srcImage ), |
| static_cast<VkImageLayout>( srcImageLayout ), |
| static_cast<VkBuffer>( dstBuffer ), |
| regions.size(), |
| reinterpret_cast<const VkBufferImageCopy *>( regions.data() ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::updateBuffer( VULKAN_HPP_NAMESPACE::Buffer dstBuffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, |
| VULKAN_HPP_NAMESPACE::DeviceSize dataSize, |
| const void * pData, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdUpdateBuffer( |
| m_commandBuffer, static_cast<VkBuffer>( dstBuffer ), static_cast<VkDeviceSize>( dstOffset ), static_cast<VkDeviceSize>( dataSize ), pData ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename DataType, typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::updateBuffer( VULKAN_HPP_NAMESPACE::Buffer dstBuffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const DataType> const & data, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdUpdateBuffer && "Function <vkCmdUpdateBuffer> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| d.vkCmdUpdateBuffer( m_commandBuffer, |
| static_cast<VkBuffer>( dstBuffer ), |
| static_cast<VkDeviceSize>( dstOffset ), |
| data.size() * sizeof( DataType ), |
| reinterpret_cast<const void *>( data.data() ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::fillBuffer( VULKAN_HPP_NAMESPACE::Buffer dstBuffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, |
| VULKAN_HPP_NAMESPACE::DeviceSize size, |
| uint32_t data, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdFillBuffer( m_commandBuffer, static_cast<VkBuffer>( dstBuffer ), static_cast<VkDeviceSize>( dstOffset ), static_cast<VkDeviceSize>( size ), data ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::clearColorImage( VULKAN_HPP_NAMESPACE::Image image, |
| VULKAN_HPP_NAMESPACE::ImageLayout imageLayout, |
| const VULKAN_HPP_NAMESPACE::ClearColorValue * pColor, |
| uint32_t rangeCount, |
| const VULKAN_HPP_NAMESPACE::ImageSubresourceRange * pRanges, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdClearColorImage( m_commandBuffer, |
| static_cast<VkImage>( image ), |
| static_cast<VkImageLayout>( imageLayout ), |
| reinterpret_cast<const VkClearColorValue *>( pColor ), |
| rangeCount, |
| reinterpret_cast<const VkImageSubresourceRange *>( pRanges ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::clearColorImage( VULKAN_HPP_NAMESPACE::Image image, |
| VULKAN_HPP_NAMESPACE::ImageLayout imageLayout, |
| const VULKAN_HPP_NAMESPACE::ClearColorValue & color, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceRange> const & ranges, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdClearColorImage && "Function <vkCmdClearColorImage> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| d.vkCmdClearColorImage( m_commandBuffer, |
| static_cast<VkImage>( image ), |
| static_cast<VkImageLayout>( imageLayout ), |
| reinterpret_cast<const VkClearColorValue *>( &color ), |
| ranges.size(), |
| reinterpret_cast<const VkImageSubresourceRange *>( ranges.data() ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::clearDepthStencilImage( VULKAN_HPP_NAMESPACE::Image image, |
| VULKAN_HPP_NAMESPACE::ImageLayout imageLayout, |
| const VULKAN_HPP_NAMESPACE::ClearDepthStencilValue * pDepthStencil, |
| uint32_t rangeCount, |
| const VULKAN_HPP_NAMESPACE::ImageSubresourceRange * pRanges, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdClearDepthStencilImage( m_commandBuffer, |
| static_cast<VkImage>( image ), |
| static_cast<VkImageLayout>( imageLayout ), |
| reinterpret_cast<const VkClearDepthStencilValue *>( pDepthStencil ), |
| rangeCount, |
| reinterpret_cast<const VkImageSubresourceRange *>( pRanges ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void |
| CommandBuffer::clearDepthStencilImage( VULKAN_HPP_NAMESPACE::Image image, |
| VULKAN_HPP_NAMESPACE::ImageLayout imageLayout, |
| const VULKAN_HPP_NAMESPACE::ClearDepthStencilValue & depthStencil, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceRange> const & ranges, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdClearDepthStencilImage && "Function <vkCmdClearDepthStencilImage> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| d.vkCmdClearDepthStencilImage( m_commandBuffer, |
| static_cast<VkImage>( image ), |
| static_cast<VkImageLayout>( imageLayout ), |
| reinterpret_cast<const VkClearDepthStencilValue *>( &depthStencil ), |
| ranges.size(), |
| reinterpret_cast<const VkImageSubresourceRange *>( ranges.data() ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::clearAttachments( uint32_t attachmentCount, |
| const VULKAN_HPP_NAMESPACE::ClearAttachment * pAttachments, |
| uint32_t rectCount, |
| const VULKAN_HPP_NAMESPACE::ClearRect * pRects, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdClearAttachments( m_commandBuffer, |
| attachmentCount, |
| reinterpret_cast<const VkClearAttachment *>( pAttachments ), |
| rectCount, |
| reinterpret_cast<const VkClearRect *>( pRects ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::clearAttachments( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearAttachment> const & attachments, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearRect> const & rects, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdClearAttachments && "Function <vkCmdClearAttachments> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| d.vkCmdClearAttachments( m_commandBuffer, |
| attachments.size(), |
| reinterpret_cast<const VkClearAttachment *>( attachments.data() ), |
| rects.size(), |
| reinterpret_cast<const VkClearRect *>( rects.data() ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::resolveImage( VULKAN_HPP_NAMESPACE::Image srcImage, |
| VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, |
| VULKAN_HPP_NAMESPACE::Image dstImage, |
| VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, |
| uint32_t regionCount, |
| const VULKAN_HPP_NAMESPACE::ImageResolve * pRegions, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdResolveImage( m_commandBuffer, |
| static_cast<VkImage>( srcImage ), |
| static_cast<VkImageLayout>( srcImageLayout ), |
| static_cast<VkImage>( dstImage ), |
| static_cast<VkImageLayout>( dstImageLayout ), |
| regionCount, |
| reinterpret_cast<const VkImageResolve *>( pRegions ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::resolveImage( VULKAN_HPP_NAMESPACE::Image srcImage, |
| VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, |
| VULKAN_HPP_NAMESPACE::Image dstImage, |
| VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageResolve> const & regions, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdResolveImage && "Function <vkCmdResolveImage> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| d.vkCmdResolveImage( m_commandBuffer, |
| static_cast<VkImage>( srcImage ), |
| static_cast<VkImageLayout>( srcImageLayout ), |
| static_cast<VkImage>( dstImage ), |
| static_cast<VkImageLayout>( dstImageLayout ), |
| regions.size(), |
| reinterpret_cast<const VkImageResolve *>( regions.data() ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setEvent( VULKAN_HPP_NAMESPACE::Event event, |
| VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetEvent( m_commandBuffer, static_cast<VkEvent>( event ), static_cast<VkPipelineStageFlags>( stageMask ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::resetEvent( VULKAN_HPP_NAMESPACE::Event event, |
| VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdResetEvent( m_commandBuffer, static_cast<VkEvent>( event ), static_cast<VkPipelineStageFlags>( stageMask ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::waitEvents( uint32_t eventCount, |
| const VULKAN_HPP_NAMESPACE::Event * pEvents, |
| VULKAN_HPP_NAMESPACE::PipelineStageFlags srcStageMask, |
| VULKAN_HPP_NAMESPACE::PipelineStageFlags dstStageMask, |
| uint32_t memoryBarrierCount, |
| const VULKAN_HPP_NAMESPACE::MemoryBarrier * pMemoryBarriers, |
| uint32_t bufferMemoryBarrierCount, |
| const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier * pBufferMemoryBarriers, |
| uint32_t imageMemoryBarrierCount, |
| const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier * pImageMemoryBarriers, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdWaitEvents( m_commandBuffer, |
| eventCount, |
| reinterpret_cast<const VkEvent *>( pEvents ), |
| static_cast<VkPipelineStageFlags>( srcStageMask ), |
| static_cast<VkPipelineStageFlags>( dstStageMask ), |
| memoryBarrierCount, |
| reinterpret_cast<const VkMemoryBarrier *>( pMemoryBarriers ), |
| bufferMemoryBarrierCount, |
| reinterpret_cast<const VkBufferMemoryBarrier *>( pBufferMemoryBarriers ), |
| imageMemoryBarrierCount, |
| reinterpret_cast<const VkImageMemoryBarrier *>( pImageMemoryBarriers ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void |
| CommandBuffer::waitEvents( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const & events, |
| VULKAN_HPP_NAMESPACE::PipelineStageFlags srcStageMask, |
| VULKAN_HPP_NAMESPACE::PipelineStageFlags dstStageMask, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryBarrier> const & memoryBarriers, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> const & bufferMemoryBarriers, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> const & imageMemoryBarriers, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdWaitEvents && "Function <vkCmdWaitEvents> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| d.vkCmdWaitEvents( m_commandBuffer, |
| events.size(), |
| reinterpret_cast<const VkEvent *>( events.data() ), |
| static_cast<VkPipelineStageFlags>( srcStageMask ), |
| static_cast<VkPipelineStageFlags>( dstStageMask ), |
| memoryBarriers.size(), |
| reinterpret_cast<const VkMemoryBarrier *>( memoryBarriers.data() ), |
| bufferMemoryBarriers.size(), |
| reinterpret_cast<const VkBufferMemoryBarrier *>( bufferMemoryBarriers.data() ), |
| imageMemoryBarriers.size(), |
| reinterpret_cast<const VkImageMemoryBarrier *>( imageMemoryBarriers.data() ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier( VULKAN_HPP_NAMESPACE::PipelineStageFlags srcStageMask, |
| VULKAN_HPP_NAMESPACE::PipelineStageFlags dstStageMask, |
| VULKAN_HPP_NAMESPACE::DependencyFlags dependencyFlags, |
| uint32_t memoryBarrierCount, |
| const VULKAN_HPP_NAMESPACE::MemoryBarrier * pMemoryBarriers, |
| uint32_t bufferMemoryBarrierCount, |
| const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier * pBufferMemoryBarriers, |
| uint32_t imageMemoryBarrierCount, |
| const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier * pImageMemoryBarriers, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdPipelineBarrier( m_commandBuffer, |
| static_cast<VkPipelineStageFlags>( srcStageMask ), |
| static_cast<VkPipelineStageFlags>( dstStageMask ), |
| static_cast<VkDependencyFlags>( dependencyFlags ), |
| memoryBarrierCount, |
| reinterpret_cast<const VkMemoryBarrier *>( pMemoryBarriers ), |
| bufferMemoryBarrierCount, |
| reinterpret_cast<const VkBufferMemoryBarrier *>( pBufferMemoryBarriers ), |
| imageMemoryBarrierCount, |
| reinterpret_cast<const VkImageMemoryBarrier *>( pImageMemoryBarriers ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void |
| CommandBuffer::pipelineBarrier( VULKAN_HPP_NAMESPACE::PipelineStageFlags srcStageMask, |
| VULKAN_HPP_NAMESPACE::PipelineStageFlags dstStageMask, |
| VULKAN_HPP_NAMESPACE::DependencyFlags dependencyFlags, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryBarrier> const & memoryBarriers, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> const & bufferMemoryBarriers, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> const & imageMemoryBarriers, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdPipelineBarrier && "Function <vkCmdPipelineBarrier> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| d.vkCmdPipelineBarrier( m_commandBuffer, |
| static_cast<VkPipelineStageFlags>( srcStageMask ), |
| static_cast<VkPipelineStageFlags>( dstStageMask ), |
| static_cast<VkDependencyFlags>( dependencyFlags ), |
| memoryBarriers.size(), |
| reinterpret_cast<const VkMemoryBarrier *>( memoryBarriers.data() ), |
| bufferMemoryBarriers.size(), |
| reinterpret_cast<const VkBufferMemoryBarrier *>( bufferMemoryBarriers.data() ), |
| imageMemoryBarriers.size(), |
| reinterpret_cast<const VkImageMemoryBarrier *>( imageMemoryBarriers.data() ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::beginQuery( VULKAN_HPP_NAMESPACE::QueryPool queryPool, |
| uint32_t query, |
| VULKAN_HPP_NAMESPACE::QueryControlFlags flags, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdBeginQuery( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query, static_cast<VkQueryControlFlags>( flags ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::endQuery( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdEndQuery( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::resetQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool, |
| uint32_t firstQuery, |
| uint32_t queryCount, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdResetQueryPool( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::writeTimestamp( VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage, |
| VULKAN_HPP_NAMESPACE::QueryPool queryPool, |
| uint32_t query, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdWriteTimestamp( m_commandBuffer, static_cast<VkPipelineStageFlagBits>( pipelineStage ), static_cast<VkQueryPool>( queryPool ), query ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::copyQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool queryPool, |
| uint32_t firstQuery, |
| uint32_t queryCount, |
| VULKAN_HPP_NAMESPACE::Buffer dstBuffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, |
| VULKAN_HPP_NAMESPACE::DeviceSize stride, |
| VULKAN_HPP_NAMESPACE::QueryResultFlags flags, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdCopyQueryPoolResults( m_commandBuffer, |
| static_cast<VkQueryPool>( queryPool ), |
| firstQuery, |
| queryCount, |
| static_cast<VkBuffer>( dstBuffer ), |
| static_cast<VkDeviceSize>( dstOffset ), |
| static_cast<VkDeviceSize>( stride ), |
| static_cast<VkQueryResultFlags>( flags ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::pushConstants( VULKAN_HPP_NAMESPACE::PipelineLayout layout, |
| VULKAN_HPP_NAMESPACE::ShaderStageFlags stageFlags, |
| uint32_t offset, |
| uint32_t size, |
| const void * pValues, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdPushConstants( m_commandBuffer, static_cast<VkPipelineLayout>( layout ), static_cast<VkShaderStageFlags>( stageFlags ), offset, size, pValues ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename ValuesType, typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::pushConstants( VULKAN_HPP_NAMESPACE::PipelineLayout layout, |
| VULKAN_HPP_NAMESPACE::ShaderStageFlags stageFlags, |
| uint32_t offset, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const ValuesType> const & values, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdPushConstants && "Function <vkCmdPushConstants> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| d.vkCmdPushConstants( m_commandBuffer, |
| static_cast<VkPipelineLayout>( layout ), |
| static_cast<VkShaderStageFlags>( stageFlags ), |
| offset, |
| values.size() * sizeof( ValuesType ), |
| reinterpret_cast<const void *>( values.data() ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo * pRenderPassBegin, |
| VULKAN_HPP_NAMESPACE::SubpassContents contents, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdBeginRenderPass( m_commandBuffer, reinterpret_cast<const VkRenderPassBeginInfo *>( pRenderPassBegin ), static_cast<VkSubpassContents>( contents ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin, |
| VULKAN_HPP_NAMESPACE::SubpassContents contents, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdBeginRenderPass && "Function <vkCmdBeginRenderPass> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| d.vkCmdBeginRenderPass( m_commandBuffer, reinterpret_cast<const VkRenderPassBeginInfo *>( &renderPassBegin ), static_cast<VkSubpassContents>( contents ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::nextSubpass( VULKAN_HPP_NAMESPACE::SubpassContents contents, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdNextSubpass( m_commandBuffer, static_cast<VkSubpassContents>( contents ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::endRenderPass( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdEndRenderPass( m_commandBuffer ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::executeCommands( uint32_t commandBufferCount, |
| const VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdExecuteCommands( m_commandBuffer, commandBufferCount, reinterpret_cast<const VkCommandBuffer *>( pCommandBuffers ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::executeCommands( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdExecuteCommands && "Function <vkCmdExecuteCommands> requires <VK_VERSION_1_0>" ); |
| # endif |
| |
| d.vkCmdExecuteCommands( m_commandBuffer, commandBuffers.size(), reinterpret_cast<const VkCommandBuffer *>( commandBuffers.data() ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_VERSION_1_1 === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result enumerateInstanceVersion( uint32_t * pApiVersion, Dispatch const & d ) VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkEnumerateInstanceVersion( pApiVersion ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<uint32_t>::type enumerateInstanceVersion( Dispatch const & d ) |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkEnumerateInstanceVersion && "Function <vkEnumerateInstanceVersion> requires <VK_VERSION_1_1>" ); |
| # endif |
| |
| uint32_t apiVersion; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkEnumerateInstanceVersion( &apiVersion ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::enumerateInstanceVersion" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( apiVersion ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::bindBufferMemory2( uint32_t bindInfoCount, |
| const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo * pBindInfos, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkBindBufferMemory2( m_device, bindInfoCount, reinterpret_cast<const VkBindBufferMemoryInfo *>( pBindInfos ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type |
| Device::bindBufferMemory2( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const & bindInfos, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkBindBufferMemory2 && "Function <vkBindBufferMemory2> requires <VK_KHR_bind_memory2> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkBindBufferMemory2( m_device, bindInfos.size(), reinterpret_cast<const VkBindBufferMemoryInfo *>( bindInfos.data() ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindBufferMemory2" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::bindImageMemory2( uint32_t bindInfoCount, |
| const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo * pBindInfos, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkBindImageMemory2( m_device, bindInfoCount, reinterpret_cast<const VkBindImageMemoryInfo *>( pBindInfos ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type |
| Device::bindImageMemory2( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const & bindInfos, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkBindImageMemory2 && "Function <vkBindImageMemory2> requires <VK_KHR_bind_memory2> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkBindImageMemory2( m_device, bindInfos.size(), reinterpret_cast<const VkBindImageMemoryInfo *>( bindInfos.data() ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindImageMemory2" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::getGroupPeerMemoryFeatures( uint32_t heapIndex, |
| uint32_t localDeviceIndex, |
| uint32_t remoteDeviceIndex, |
| VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags * pPeerMemoryFeatures, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetDeviceGroupPeerMemoryFeatures( |
| m_device, heapIndex, localDeviceIndex, remoteDeviceIndex, reinterpret_cast<VkPeerMemoryFeatureFlags *>( pPeerMemoryFeatures ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags Device::getGroupPeerMemoryFeatures( |
| uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetDeviceGroupPeerMemoryFeatures && |
| "Function <vkGetDeviceGroupPeerMemoryFeatures> requires <VK_KHR_device_group> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags peerMemoryFeatures; |
| d.vkGetDeviceGroupPeerMemoryFeatures( |
| m_device, heapIndex, localDeviceIndex, remoteDeviceIndex, reinterpret_cast<VkPeerMemoryFeatureFlags *>( &peerMemoryFeatures ) ); |
| |
| return peerMemoryFeatures; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setDeviceMask( uint32_t deviceMask, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetDeviceMask( m_commandBuffer, deviceMask ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::dispatchBase( uint32_t baseGroupX, |
| uint32_t baseGroupY, |
| uint32_t baseGroupZ, |
| uint32_t groupCountX, |
| uint32_t groupCountY, |
| uint32_t groupCountZ, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdDispatchBase( m_commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| Instance::enumeratePhysicalDeviceGroups( uint32_t * pPhysicalDeviceGroupCount, |
| VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkEnumeratePhysicalDeviceGroups( |
| m_instance, pPhysicalDeviceGroupCount, reinterpret_cast<VkPhysicalDeviceGroupProperties *>( pPhysicalDeviceGroupProperties ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename PhysicalDeviceGroupPropertiesAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE |
| typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type |
| Instance::enumeratePhysicalDeviceGroups( Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkEnumeratePhysicalDeviceGroups && |
| "Function <vkEnumeratePhysicalDeviceGroups> requires <VK_KHR_device_group_creation> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator> physicalDeviceGroupProperties; |
| uint32_t physicalDeviceGroupCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkEnumeratePhysicalDeviceGroups( m_instance, &physicalDeviceGroupCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && physicalDeviceGroupCount ) |
| { |
| physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkEnumeratePhysicalDeviceGroups( |
| m_instance, &physicalDeviceGroupCount, reinterpret_cast<VkPhysicalDeviceGroupProperties *>( physicalDeviceGroupProperties.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::enumeratePhysicalDeviceGroups" ); |
| VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() ); |
| if ( physicalDeviceGroupCount < physicalDeviceGroupProperties.size() ) |
| { |
| physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( physicalDeviceGroupProperties ) ); |
| } |
| |
| template <typename PhysicalDeviceGroupPropertiesAllocator, |
| typename Dispatch, |
| typename std::enable_if< |
| std::is_same<typename PhysicalDeviceGroupPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>::value, |
| int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE |
| typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type |
| Instance::enumeratePhysicalDeviceGroups( PhysicalDeviceGroupPropertiesAllocator & physicalDeviceGroupPropertiesAllocator, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkEnumeratePhysicalDeviceGroups && |
| "Function <vkEnumeratePhysicalDeviceGroups> requires <VK_KHR_device_group_creation> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator> physicalDeviceGroupProperties( |
| physicalDeviceGroupPropertiesAllocator ); |
| uint32_t physicalDeviceGroupCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkEnumeratePhysicalDeviceGroups( m_instance, &physicalDeviceGroupCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && physicalDeviceGroupCount ) |
| { |
| physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkEnumeratePhysicalDeviceGroups( |
| m_instance, &physicalDeviceGroupCount, reinterpret_cast<VkPhysicalDeviceGroupProperties *>( physicalDeviceGroupProperties.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::enumeratePhysicalDeviceGroups" ); |
| VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() ); |
| if ( physicalDeviceGroupCount < physicalDeviceGroupProperties.size() ) |
| { |
| physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( physicalDeviceGroupProperties ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::getImageMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 * pInfo, |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetImageMemoryRequirements2( |
| m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>( pInfo ), reinterpret_cast<VkMemoryRequirements2 *>( pMemoryRequirements ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2 |
| Device::getImageMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetImageMemoryRequirements2 && |
| "Function <vkGetImageMemoryRequirements2> requires <VK_KHR_get_memory_requirements2> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements; |
| d.vkGetImageMemoryRequirements2( |
| m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>( &info ), reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) ); |
| |
| return memoryRequirements; |
| } |
| |
| template <typename X, typename Y, typename... Z, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> |
| Device::getImageMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetImageMemoryRequirements2 && |
| "Function <vkGetImageMemoryRequirements2> requires <VK_KHR_get_memory_requirements2> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain; |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>(); |
| d.vkGetImageMemoryRequirements2( |
| m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>( &info ), reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) ); |
| |
| return structureChain; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::getBufferMemoryRequirements2( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 * pInfo, |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetBufferMemoryRequirements2( |
| m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>( pInfo ), reinterpret_cast<VkMemoryRequirements2 *>( pMemoryRequirements ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2 |
| Device::getBufferMemoryRequirements2( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetBufferMemoryRequirements2 && |
| "Function <vkGetBufferMemoryRequirements2> requires <VK_KHR_get_memory_requirements2> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements; |
| d.vkGetBufferMemoryRequirements2( |
| m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>( &info ), reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) ); |
| |
| return memoryRequirements; |
| } |
| |
| template <typename X, typename Y, typename... Z, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> |
| Device::getBufferMemoryRequirements2( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetBufferMemoryRequirements2 && |
| "Function <vkGetBufferMemoryRequirements2> requires <VK_KHR_get_memory_requirements2> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain; |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>(); |
| d.vkGetBufferMemoryRequirements2( |
| m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>( &info ), reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) ); |
| |
| return structureChain; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 * pInfo, |
| uint32_t * pSparseMemoryRequirementCount, |
| VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 * pSparseMemoryRequirements, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetImageSparseMemoryRequirements2( m_device, |
| reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( pInfo ), |
| pSparseMemoryRequirementCount, |
| reinterpret_cast<VkSparseImageMemoryRequirements2 *>( pSparseMemoryRequirements ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename SparseImageMemoryRequirements2Allocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> |
| Device::getImageSparseMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetImageSparseMemoryRequirements2 && |
| "Function <vkGetImageSparseMemoryRequirements2> requires <VK_KHR_get_memory_requirements2> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> sparseMemoryRequirements; |
| uint32_t sparseMemoryRequirementCount; |
| d.vkGetImageSparseMemoryRequirements2( |
| m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ), &sparseMemoryRequirementCount, nullptr ); |
| sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); |
| d.vkGetImageSparseMemoryRequirements2( m_device, |
| reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ), |
| &sparseMemoryRequirementCount, |
| reinterpret_cast<VkSparseImageMemoryRequirements2 *>( sparseMemoryRequirements.data() ) ); |
| |
| VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() ); |
| if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() ) |
| { |
| sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); |
| } |
| return sparseMemoryRequirements; |
| } |
| |
| template <typename SparseImageMemoryRequirements2Allocator, |
| typename Dispatch, |
| typename std::enable_if< |
| std::is_same<typename SparseImageMemoryRequirements2Allocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>::value, |
| int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> |
| Device::getImageSparseMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info, |
| SparseImageMemoryRequirements2Allocator & sparseImageMemoryRequirements2Allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetImageSparseMemoryRequirements2 && |
| "Function <vkGetImageSparseMemoryRequirements2> requires <VK_KHR_get_memory_requirements2> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> sparseMemoryRequirements( |
| sparseImageMemoryRequirements2Allocator ); |
| uint32_t sparseMemoryRequirementCount; |
| d.vkGetImageSparseMemoryRequirements2( |
| m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ), &sparseMemoryRequirementCount, nullptr ); |
| sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); |
| d.vkGetImageSparseMemoryRequirements2( m_device, |
| reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ), |
| &sparseMemoryRequirementCount, |
| reinterpret_cast<VkSparseImageMemoryRequirements2 *>( sparseMemoryRequirements.data() ) ); |
| |
| VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() ); |
| if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() ) |
| { |
| sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); |
| } |
| return sparseMemoryRequirements; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void PhysicalDevice::getFeatures2( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 * pFeatures, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetPhysicalDeviceFeatures2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2 *>( pFeatures ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 |
| PhysicalDevice::getFeatures2( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceFeatures2 && |
| "Function <vkGetPhysicalDeviceFeatures2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 features; |
| d.vkGetPhysicalDeviceFeatures2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2 *>( &features ) ); |
| |
| return features; |
| } |
| |
| template <typename X, typename Y, typename... Z, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> |
| PhysicalDevice::getFeatures2( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceFeatures2 && |
| "Function <vkGetPhysicalDeviceFeatures2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain; |
| VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 & features = structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2>(); |
| d.vkGetPhysicalDeviceFeatures2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2 *>( &features ) ); |
| |
| return structureChain; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void PhysicalDevice::getProperties2( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 * pProperties, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetPhysicalDeviceProperties2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2 *>( pProperties ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 |
| PhysicalDevice::getProperties2( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceProperties2 && |
| "Function <vkGetPhysicalDeviceProperties2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 properties; |
| d.vkGetPhysicalDeviceProperties2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2 *>( &properties ) ); |
| |
| return properties; |
| } |
| |
| template <typename X, typename Y, typename... Z, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> |
| PhysicalDevice::getProperties2( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceProperties2 && |
| "Function <vkGetPhysicalDeviceProperties2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain; |
| VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 & properties = structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2>(); |
| d.vkGetPhysicalDeviceProperties2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2 *>( &properties ) ); |
| |
| return structureChain; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void PhysicalDevice::getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format, |
| VULKAN_HPP_NAMESPACE::FormatProperties2 * pFormatProperties, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetPhysicalDeviceFormatProperties2( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2 *>( pFormatProperties ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::FormatProperties2 |
| PhysicalDevice::getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceFormatProperties2 && |
| "Function <vkGetPhysicalDeviceFormatProperties2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::FormatProperties2 formatProperties; |
| d.vkGetPhysicalDeviceFormatProperties2( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2 *>( &formatProperties ) ); |
| |
| return formatProperties; |
| } |
| |
| template <typename X, typename Y, typename... Z, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> |
| PhysicalDevice::getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceFormatProperties2 && |
| "Function <vkGetPhysicalDeviceFormatProperties2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain; |
| VULKAN_HPP_NAMESPACE::FormatProperties2 & formatProperties = structureChain.template get<VULKAN_HPP_NAMESPACE::FormatProperties2>(); |
| d.vkGetPhysicalDeviceFormatProperties2( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2 *>( &formatProperties ) ); |
| |
| return structureChain; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| PhysicalDevice::getImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 * pImageFormatInfo, |
| VULKAN_HPP_NAMESPACE::ImageFormatProperties2 * pImageFormatProperties, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2( m_physicalDevice, |
| reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>( pImageFormatInfo ), |
| reinterpret_cast<VkImageFormatProperties2 *>( pImageFormatProperties ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>::type |
| PhysicalDevice::getImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceImageFormatProperties2 && |
| "Function <vkGetPhysicalDeviceImageFormatProperties2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::ImageFormatProperties2 imageFormatProperties; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetPhysicalDeviceImageFormatProperties2( m_physicalDevice, |
| reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>( &imageFormatInfo ), |
| reinterpret_cast<VkImageFormatProperties2 *>( &imageFormatProperties ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( imageFormatProperties ) ); |
| } |
| |
| template <typename X, typename Y, typename... Z, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>>::type |
| PhysicalDevice::getImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceImageFormatProperties2 && |
| "Function <vkGetPhysicalDeviceImageFormatProperties2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| StructureChain<X, Y, Z...> structureChain; |
| VULKAN_HPP_NAMESPACE::ImageFormatProperties2 & imageFormatProperties = structureChain.template get<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>(); |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetPhysicalDeviceImageFormatProperties2( m_physicalDevice, |
| reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>( &imageFormatInfo ), |
| reinterpret_cast<VkImageFormatProperties2 *>( &imageFormatProperties ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( structureChain ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void PhysicalDevice::getQueueFamilyProperties2( uint32_t * pQueueFamilyPropertyCount, |
| VULKAN_HPP_NAMESPACE::QueueFamilyProperties2 * pQueueFamilyProperties, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetPhysicalDeviceQueueFamilyProperties2( |
| m_physicalDevice, pQueueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2 *>( pQueueFamilyProperties ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename QueueFamilyProperties2Allocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2, QueueFamilyProperties2Allocator> |
| PhysicalDevice::getQueueFamilyProperties2( Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyProperties2 && |
| "Function <vkGetPhysicalDeviceQueueFamilyProperties2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2, QueueFamilyProperties2Allocator> queueFamilyProperties; |
| uint32_t queueFamilyPropertyCount; |
| d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, nullptr ); |
| queueFamilyProperties.resize( queueFamilyPropertyCount ); |
| d.vkGetPhysicalDeviceQueueFamilyProperties2( |
| m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) ); |
| |
| VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() ); |
| if ( queueFamilyPropertyCount < queueFamilyProperties.size() ) |
| { |
| queueFamilyProperties.resize( queueFamilyPropertyCount ); |
| } |
| return queueFamilyProperties; |
| } |
| |
| template < |
| typename QueueFamilyProperties2Allocator, |
| typename Dispatch, |
| typename std::enable_if<std::is_same<typename QueueFamilyProperties2Allocator::value_type, VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>::value, int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2, QueueFamilyProperties2Allocator> |
| PhysicalDevice::getQueueFamilyProperties2( QueueFamilyProperties2Allocator & queueFamilyProperties2Allocator, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyProperties2 && |
| "Function <vkGetPhysicalDeviceQueueFamilyProperties2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2, QueueFamilyProperties2Allocator> queueFamilyProperties( queueFamilyProperties2Allocator ); |
| uint32_t queueFamilyPropertyCount; |
| d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, nullptr ); |
| queueFamilyProperties.resize( queueFamilyPropertyCount ); |
| d.vkGetPhysicalDeviceQueueFamilyProperties2( |
| m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) ); |
| |
| VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() ); |
| if ( queueFamilyPropertyCount < queueFamilyProperties.size() ) |
| { |
| queueFamilyProperties.resize( queueFamilyPropertyCount ); |
| } |
| return queueFamilyProperties; |
| } |
| |
| template <typename StructureChain, typename StructureChainAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<StructureChain, StructureChainAllocator> |
| PhysicalDevice::getQueueFamilyProperties2( Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyProperties2 && |
| "Function <vkGetPhysicalDeviceQueueFamilyProperties2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| std::vector<StructureChain, StructureChainAllocator> structureChains; |
| std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> queueFamilyProperties; |
| uint32_t queueFamilyPropertyCount; |
| d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, nullptr ); |
| structureChains.resize( queueFamilyPropertyCount ); |
| queueFamilyProperties.resize( queueFamilyPropertyCount ); |
| for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ ) |
| { |
| queueFamilyProperties[i].pNext = structureChains[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>().pNext; |
| } |
| d.vkGetPhysicalDeviceQueueFamilyProperties2( |
| m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) ); |
| |
| VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() ); |
| if ( queueFamilyPropertyCount < queueFamilyProperties.size() ) |
| { |
| structureChains.resize( queueFamilyPropertyCount ); |
| } |
| for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ ) |
| { |
| structureChains[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>() = queueFamilyProperties[i]; |
| } |
| return structureChains; |
| } |
| |
| template <typename StructureChain, |
| typename StructureChainAllocator, |
| typename Dispatch, |
| typename std::enable_if<std::is_same<typename StructureChainAllocator::value_type, StructureChain>::value, int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<StructureChain, StructureChainAllocator> |
| PhysicalDevice::getQueueFamilyProperties2( StructureChainAllocator & structureChainAllocator, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyProperties2 && |
| "Function <vkGetPhysicalDeviceQueueFamilyProperties2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| std::vector<StructureChain, StructureChainAllocator> structureChains( structureChainAllocator ); |
| std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> queueFamilyProperties; |
| uint32_t queueFamilyPropertyCount; |
| d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, nullptr ); |
| structureChains.resize( queueFamilyPropertyCount ); |
| queueFamilyProperties.resize( queueFamilyPropertyCount ); |
| for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ ) |
| { |
| queueFamilyProperties[i].pNext = structureChains[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>().pNext; |
| } |
| d.vkGetPhysicalDeviceQueueFamilyProperties2( |
| m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) ); |
| |
| VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() ); |
| if ( queueFamilyPropertyCount < queueFamilyProperties.size() ) |
| { |
| structureChains.resize( queueFamilyPropertyCount ); |
| } |
| for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ ) |
| { |
| structureChains[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>() = queueFamilyProperties[i]; |
| } |
| return structureChains; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void PhysicalDevice::getMemoryProperties2( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 * pMemoryProperties, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetPhysicalDeviceMemoryProperties2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>( pMemoryProperties ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 |
| PhysicalDevice::getMemoryProperties2( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceMemoryProperties2 && |
| "Function <vkGetPhysicalDeviceMemoryProperties2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 memoryProperties; |
| d.vkGetPhysicalDeviceMemoryProperties2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>( &memoryProperties ) ); |
| |
| return memoryProperties; |
| } |
| |
| template <typename X, typename Y, typename... Z, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> |
| PhysicalDevice::getMemoryProperties2( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceMemoryProperties2 && |
| "Function <vkGetPhysicalDeviceMemoryProperties2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain; |
| VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 & memoryProperties = |
| structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2>(); |
| d.vkGetPhysicalDeviceMemoryProperties2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>( &memoryProperties ) ); |
| |
| return structureChain; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void PhysicalDevice::getSparseImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 * pFormatInfo, |
| uint32_t * pPropertyCount, |
| VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 * pProperties, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetPhysicalDeviceSparseImageFormatProperties2( m_physicalDevice, |
| reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( pFormatInfo ), |
| pPropertyCount, |
| reinterpret_cast<VkSparseImageFormatProperties2 *>( pProperties ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename SparseImageFormatProperties2Allocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2, SparseImageFormatProperties2Allocator> |
| PhysicalDevice::getSparseImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSparseImageFormatProperties2 && |
| "Function <vkGetPhysicalDeviceSparseImageFormatProperties2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2, SparseImageFormatProperties2Allocator> properties; |
| uint32_t propertyCount; |
| d.vkGetPhysicalDeviceSparseImageFormatProperties2( |
| m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ), &propertyCount, nullptr ); |
| properties.resize( propertyCount ); |
| d.vkGetPhysicalDeviceSparseImageFormatProperties2( m_physicalDevice, |
| reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ), |
| &propertyCount, |
| reinterpret_cast<VkSparseImageFormatProperties2 *>( properties.data() ) ); |
| |
| VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); |
| if ( propertyCount < properties.size() ) |
| { |
| properties.resize( propertyCount ); |
| } |
| return properties; |
| } |
| |
| template < |
| typename SparseImageFormatProperties2Allocator, |
| typename Dispatch, |
| typename std::enable_if<std::is_same<typename SparseImageFormatProperties2Allocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>::value, |
| int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2, SparseImageFormatProperties2Allocator> |
| PhysicalDevice::getSparseImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo, |
| SparseImageFormatProperties2Allocator & sparseImageFormatProperties2Allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSparseImageFormatProperties2 && |
| "Function <vkGetPhysicalDeviceSparseImageFormatProperties2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2, SparseImageFormatProperties2Allocator> properties( sparseImageFormatProperties2Allocator ); |
| uint32_t propertyCount; |
| d.vkGetPhysicalDeviceSparseImageFormatProperties2( |
| m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ), &propertyCount, nullptr ); |
| properties.resize( propertyCount ); |
| d.vkGetPhysicalDeviceSparseImageFormatProperties2( m_physicalDevice, |
| reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ), |
| &propertyCount, |
| reinterpret_cast<VkSparseImageFormatProperties2 *>( properties.data() ) ); |
| |
| VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); |
| if ( propertyCount < properties.size() ) |
| { |
| properties.resize( propertyCount ); |
| } |
| return properties; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::trimCommandPool( VULKAN_HPP_NAMESPACE::CommandPool commandPool, |
| VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkTrimCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolTrimFlags>( flags ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::getQueue2( const VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 * pQueueInfo, |
| VULKAN_HPP_NAMESPACE::Queue * pQueue, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetDeviceQueue2( m_device, reinterpret_cast<const VkDeviceQueueInfo2 *>( pQueueInfo ), reinterpret_cast<VkQueue *>( pQueue ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Queue Device::getQueue2( const VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 & queueInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetDeviceQueue2 && "Function <vkGetDeviceQueue2> requires <VK_VERSION_1_1>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Queue queue; |
| d.vkGetDeviceQueue2( m_device, reinterpret_cast<const VkDeviceQueueInfo2 *>( &queueInfo ), reinterpret_cast<VkQueue *>( &queue ) ); |
| |
| return queue; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| Device::createSamplerYcbcrConversion( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion * pYcbcrConversion, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateSamplerYcbcrConversion( m_device, |
| reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkSamplerYcbcrConversion *>( pYcbcrConversion ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>::type |
| Device::createSamplerYcbcrConversion( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateSamplerYcbcrConversion && |
| "Function <vkCreateSamplerYcbcrConversion> requires <VK_KHR_sampler_ycbcr_conversion> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateSamplerYcbcrConversion( |
| m_device, |
| reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkSamplerYcbcrConversion *>( &ycbcrConversion ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSamplerYcbcrConversion" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( ycbcrConversion ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion, Dispatch>>::type |
| Device::createSamplerYcbcrConversionUnique( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateSamplerYcbcrConversion && |
| "Function <vkCreateSamplerYcbcrConversion> requires <VK_KHR_sampler_ycbcr_conversion> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateSamplerYcbcrConversion( |
| m_device, |
| reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkSamplerYcbcrConversion *>( &ycbcrConversion ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSamplerYcbcrConversionUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion, Dispatch>( ycbcrConversion, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroySamplerYcbcrConversion( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroySamplerYcbcrConversion( |
| m_device, static_cast<VkSamplerYcbcrConversion>( ycbcrConversion ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroySamplerYcbcrConversion( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroySamplerYcbcrConversion && |
| "Function <vkDestroySamplerYcbcrConversion> requires <VK_KHR_sampler_ycbcr_conversion> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| d.vkDestroySamplerYcbcrConversion( |
| m_device, |
| static_cast<VkSamplerYcbcrConversion>( ycbcrConversion ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroySamplerYcbcrConversion( |
| m_device, static_cast<VkSamplerYcbcrConversion>( ycbcrConversion ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroySamplerYcbcrConversion && |
| "Function <vkDestroySamplerYcbcrConversion> requires <VK_KHR_sampler_ycbcr_conversion> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| d.vkDestroySamplerYcbcrConversion( |
| m_device, |
| static_cast<VkSamplerYcbcrConversion>( ycbcrConversion ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| Device::createDescriptorUpdateTemplate( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate * pDescriptorUpdateTemplate, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateDescriptorUpdateTemplate( m_device, |
| reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkDescriptorUpdateTemplate *>( pDescriptorUpdateTemplate ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate>::type |
| Device::createDescriptorUpdateTemplate( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateDescriptorUpdateTemplate && |
| "Function <vkCreateDescriptorUpdateTemplate> requires <VK_KHR_descriptor_update_template> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateDescriptorUpdateTemplate( |
| m_device, |
| reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkDescriptorUpdateTemplate *>( &descriptorUpdateTemplate ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorUpdateTemplate" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( descriptorUpdateTemplate ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate, Dispatch>>::type |
| Device::createDescriptorUpdateTemplateUnique( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateDescriptorUpdateTemplate && |
| "Function <vkCreateDescriptorUpdateTemplate> requires <VK_KHR_descriptor_update_template> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateDescriptorUpdateTemplate( |
| m_device, |
| reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkDescriptorUpdateTemplate *>( &descriptorUpdateTemplate ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorUpdateTemplateUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, |
| UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate, Dispatch>( |
| descriptorUpdateTemplate, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplate( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyDescriptorUpdateTemplate( |
| m_device, static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplate( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyDescriptorUpdateTemplate && |
| "Function <vkDestroyDescriptorUpdateTemplate> requires <VK_KHR_descriptor_update_template> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| d.vkDestroyDescriptorUpdateTemplate( |
| m_device, |
| static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyDescriptorUpdateTemplate( |
| m_device, static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyDescriptorUpdateTemplate && |
| "Function <vkDestroyDescriptorUpdateTemplate> requires <VK_KHR_descriptor_update_template> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| d.vkDestroyDescriptorUpdateTemplate( |
| m_device, |
| static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::updateDescriptorSetWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet, |
| VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, |
| const void * pData, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkUpdateDescriptorSetWithTemplate( |
| m_device, static_cast<VkDescriptorSet>( descriptorSet ), static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), pData ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename DataType, typename Dispatch> |
| VULKAN_HPP_INLINE void Device::updateDescriptorSetWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet, |
| VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, |
| DataType const & data, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkUpdateDescriptorSetWithTemplate && |
| "Function <vkUpdateDescriptorSetWithTemplate> requires <VK_KHR_descriptor_update_template> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| d.vkUpdateDescriptorSetWithTemplate( m_device, |
| static_cast<VkDescriptorSet>( descriptorSet ), |
| static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), |
| reinterpret_cast<const void *>( &data ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void PhysicalDevice::getExternalBufferProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo * pExternalBufferInfo, |
| VULKAN_HPP_NAMESPACE::ExternalBufferProperties * pExternalBufferProperties, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetPhysicalDeviceExternalBufferProperties( m_physicalDevice, |
| reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo *>( pExternalBufferInfo ), |
| reinterpret_cast<VkExternalBufferProperties *>( pExternalBufferProperties ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalBufferProperties |
| PhysicalDevice::getExternalBufferProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo & externalBufferInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceExternalBufferProperties && |
| "Function <vkGetPhysicalDeviceExternalBufferProperties> requires <VK_KHR_external_memory_capabilities> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::ExternalBufferProperties externalBufferProperties; |
| d.vkGetPhysicalDeviceExternalBufferProperties( m_physicalDevice, |
| reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo *>( &externalBufferInfo ), |
| reinterpret_cast<VkExternalBufferProperties *>( &externalBufferProperties ) ); |
| |
| return externalBufferProperties; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void PhysicalDevice::getExternalFenceProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo * pExternalFenceInfo, |
| VULKAN_HPP_NAMESPACE::ExternalFenceProperties * pExternalFenceProperties, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetPhysicalDeviceExternalFenceProperties( m_physicalDevice, |
| reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo *>( pExternalFenceInfo ), |
| reinterpret_cast<VkExternalFenceProperties *>( pExternalFenceProperties ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalFenceProperties |
| PhysicalDevice::getExternalFenceProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo & externalFenceInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceExternalFenceProperties && |
| "Function <vkGetPhysicalDeviceExternalFenceProperties> requires <VK_KHR_external_fence_capabilities> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::ExternalFenceProperties externalFenceProperties; |
| d.vkGetPhysicalDeviceExternalFenceProperties( m_physicalDevice, |
| reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo *>( &externalFenceInfo ), |
| reinterpret_cast<VkExternalFenceProperties *>( &externalFenceProperties ) ); |
| |
| return externalFenceProperties; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void |
| PhysicalDevice::getExternalSemaphoreProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo, |
| VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties * pExternalSemaphoreProperties, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetPhysicalDeviceExternalSemaphoreProperties( m_physicalDevice, |
| reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo *>( pExternalSemaphoreInfo ), |
| reinterpret_cast<VkExternalSemaphoreProperties *>( pExternalSemaphoreProperties ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties |
| PhysicalDevice::getExternalSemaphoreProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceExternalSemaphoreProperties && |
| "Function <vkGetPhysicalDeviceExternalSemaphoreProperties> requires <VK_KHR_external_semaphore_capabilities> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties externalSemaphoreProperties; |
| d.vkGetPhysicalDeviceExternalSemaphoreProperties( m_physicalDevice, |
| reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo *>( &externalSemaphoreInfo ), |
| reinterpret_cast<VkExternalSemaphoreProperties *>( &externalSemaphoreProperties ) ); |
| |
| return externalSemaphoreProperties; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::getDescriptorSetLayoutSupport( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo * pCreateInfo, |
| VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport * pSupport, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetDescriptorSetLayoutSupport( |
| m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( pCreateInfo ), reinterpret_cast<VkDescriptorSetLayoutSupport *>( pSupport ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport |
| Device::getDescriptorSetLayoutSupport( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetDescriptorSetLayoutSupport && "Function <vkGetDescriptorSetLayoutSupport> requires <VK_KHR_maintenance3> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport support; |
| d.vkGetDescriptorSetLayoutSupport( |
| m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( &createInfo ), reinterpret_cast<VkDescriptorSetLayoutSupport *>( &support ) ); |
| |
| return support; |
| } |
| |
| template <typename X, typename Y, typename... Z, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> |
| Device::getDescriptorSetLayoutSupport( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetDescriptorSetLayoutSupport && "Function <vkGetDescriptorSetLayoutSupport> requires <VK_KHR_maintenance3> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain; |
| VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport & support = structureChain.template get<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport>(); |
| d.vkGetDescriptorSetLayoutSupport( |
| m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( &createInfo ), reinterpret_cast<VkDescriptorSetLayoutSupport *>( &support ) ); |
| |
| return structureChain; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_VERSION_1_2 === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCount( VULKAN_HPP_NAMESPACE::Buffer buffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize offset, |
| VULKAN_HPP_NAMESPACE::Buffer countBuffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, |
| uint32_t maxDrawCount, |
| uint32_t stride, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdDrawIndirectCount( m_commandBuffer, |
| static_cast<VkBuffer>( buffer ), |
| static_cast<VkDeviceSize>( offset ), |
| static_cast<VkBuffer>( countBuffer ), |
| static_cast<VkDeviceSize>( countBufferOffset ), |
| maxDrawCount, |
| stride ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCount( VULKAN_HPP_NAMESPACE::Buffer buffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize offset, |
| VULKAN_HPP_NAMESPACE::Buffer countBuffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, |
| uint32_t maxDrawCount, |
| uint32_t stride, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdDrawIndexedIndirectCount( m_commandBuffer, |
| static_cast<VkBuffer>( buffer ), |
| static_cast<VkDeviceSize>( offset ), |
| static_cast<VkBuffer>( countBuffer ), |
| static_cast<VkDeviceSize>( countBufferOffset ), |
| maxDrawCount, |
| stride ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::RenderPass * pRenderPass, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateRenderPass2( m_device, |
| reinterpret_cast<const VkRenderPassCreateInfo2 *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkRenderPass *>( pRenderPass ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::RenderPass>::type |
| Device::createRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateRenderPass2 && "Function <vkCreateRenderPass2> requires <VK_KHR_create_renderpass2> or <VK_VERSION_1_2>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::RenderPass renderPass; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateRenderPass2( m_device, |
| reinterpret_cast<const VkRenderPassCreateInfo2 *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkRenderPass *>( &renderPass ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPass2" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( renderPass ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>>::type |
| Device::createRenderPass2Unique( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateRenderPass2 && "Function <vkCreateRenderPass2> requires <VK_KHR_create_renderpass2> or <VK_VERSION_1_2>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::RenderPass renderPass; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateRenderPass2( m_device, |
| reinterpret_cast<const VkRenderPassCreateInfo2 *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkRenderPass *>( &renderPass ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPass2Unique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>( renderPass, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo * pRenderPassBegin, |
| const VULKAN_HPP_NAMESPACE::SubpassBeginInfo * pSubpassBeginInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdBeginRenderPass2( |
| m_commandBuffer, reinterpret_cast<const VkRenderPassBeginInfo *>( pRenderPassBegin ), reinterpret_cast<const VkSubpassBeginInfo *>( pSubpassBeginInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin, |
| const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdBeginRenderPass2 && "Function <vkCmdBeginRenderPass2> requires <VK_KHR_create_renderpass2> or <VK_VERSION_1_2>" ); |
| # endif |
| |
| d.vkCmdBeginRenderPass2( |
| m_commandBuffer, reinterpret_cast<const VkRenderPassBeginInfo *>( &renderPassBegin ), reinterpret_cast<const VkSubpassBeginInfo *>( &subpassBeginInfo ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::nextSubpass2( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo * pSubpassBeginInfo, |
| const VULKAN_HPP_NAMESPACE::SubpassEndInfo * pSubpassEndInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdNextSubpass2( |
| m_commandBuffer, reinterpret_cast<const VkSubpassBeginInfo *>( pSubpassBeginInfo ), reinterpret_cast<const VkSubpassEndInfo *>( pSubpassEndInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::nextSubpass2( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo, |
| const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdNextSubpass2 && "Function <vkCmdNextSubpass2> requires <VK_KHR_create_renderpass2> or <VK_VERSION_1_2>" ); |
| # endif |
| |
| d.vkCmdNextSubpass2( |
| m_commandBuffer, reinterpret_cast<const VkSubpassBeginInfo *>( &subpassBeginInfo ), reinterpret_cast<const VkSubpassEndInfo *>( &subpassEndInfo ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::endRenderPass2( const VULKAN_HPP_NAMESPACE::SubpassEndInfo * pSubpassEndInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdEndRenderPass2( m_commandBuffer, reinterpret_cast<const VkSubpassEndInfo *>( pSubpassEndInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::endRenderPass2( const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdEndRenderPass2 && "Function <vkCmdEndRenderPass2> requires <VK_KHR_create_renderpass2> or <VK_VERSION_1_2>" ); |
| # endif |
| |
| d.vkCmdEndRenderPass2( m_commandBuffer, reinterpret_cast<const VkSubpassEndInfo *>( &subpassEndInfo ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void |
| Device::resetQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkResetQueryPool( m_device, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSemaphoreCounterValue( VULKAN_HPP_NAMESPACE::Semaphore semaphore, |
| uint64_t * pValue, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetSemaphoreCounterValue( m_device, static_cast<VkSemaphore>( semaphore ), pValue ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<uint64_t>::type Device::getSemaphoreCounterValue( VULKAN_HPP_NAMESPACE::Semaphore semaphore, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetSemaphoreCounterValue && "Function <vkGetSemaphoreCounterValue> requires <VK_KHR_timeline_semaphore> or <VK_VERSION_1_2>" ); |
| # endif |
| |
| uint64_t value; |
| VULKAN_HPP_NAMESPACE::Result result = |
| static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetSemaphoreCounterValue( m_device, static_cast<VkSemaphore>( semaphore ), &value ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreCounterValue" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( value ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::waitSemaphores( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo * pWaitInfo, |
| uint64_t timeout, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkWaitSemaphores( m_device, reinterpret_cast<const VkSemaphoreWaitInfo *>( pWaitInfo ), timeout ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result |
| Device::waitSemaphores( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo & waitInfo, uint64_t timeout, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkWaitSemaphores && "Function <vkWaitSemaphores> requires <VK_KHR_timeline_semaphore> or <VK_VERSION_1_2>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = |
| static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkWaitSemaphores( m_device, reinterpret_cast<const VkSemaphoreWaitInfo *>( &waitInfo ), timeout ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( |
| result, VULKAN_HPP_NAMESPACE_STRING "::Device::waitSemaphores", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eTimeout } ); |
| |
| return static_cast<VULKAN_HPP_NAMESPACE::Result>( result ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::signalSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo * pSignalInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkSignalSemaphore( m_device, reinterpret_cast<const VkSemaphoreSignalInfo *>( pSignalInfo ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type |
| Device::signalSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo & signalInfo, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkSignalSemaphore && "Function <vkSignalSemaphore> requires <VK_KHR_timeline_semaphore> or <VK_VERSION_1_2>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = |
| static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkSignalSemaphore( m_device, reinterpret_cast<const VkSemaphoreSignalInfo *>( &signalInfo ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::signalSemaphore" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<DeviceAddress>( d.vkGetBufferDeviceAddress( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo *>( pInfo ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceAddress Device::getBufferAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetBufferDeviceAddress && |
| "Function <vkGetBufferDeviceAddress> requires <VK_EXT_buffer_device_address> or <VK_KHR_buffer_device_address> or <VK_VERSION_1_2>" ); |
| # endif |
| |
| VkDeviceAddress result = d.vkGetBufferDeviceAddress( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo *>( &info ) ); |
| |
| return static_cast<VULKAN_HPP_NAMESPACE::DeviceAddress>( result ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE uint64_t Device::getBufferOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return d.vkGetBufferOpaqueCaptureAddress( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo *>( pInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE uint64_t Device::getBufferOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetBufferOpaqueCaptureAddress && |
| "Function <vkGetBufferOpaqueCaptureAddress> requires <VK_KHR_buffer_device_address> or <VK_VERSION_1_2>" ); |
| # endif |
| |
| uint64_t result = d.vkGetBufferOpaqueCaptureAddress( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo *>( &info ) ); |
| |
| return result; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE uint64_t Device::getMemoryOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo * pInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return d.vkGetDeviceMemoryOpaqueCaptureAddress( m_device, reinterpret_cast<const VkDeviceMemoryOpaqueCaptureAddressInfo *>( pInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE uint64_t Device::getMemoryOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo & info, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetDeviceMemoryOpaqueCaptureAddress && |
| "Function <vkGetDeviceMemoryOpaqueCaptureAddress> requires <VK_KHR_buffer_device_address> or <VK_VERSION_1_2>" ); |
| # endif |
| |
| uint64_t result = d.vkGetDeviceMemoryOpaqueCaptureAddress( m_device, reinterpret_cast<const VkDeviceMemoryOpaqueCaptureAddressInfo *>( &info ) ); |
| |
| return result; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_VERSION_1_3 === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getToolProperties( uint32_t * pToolCount, |
| VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties * pToolProperties, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( |
| d.vkGetPhysicalDeviceToolProperties( m_physicalDevice, pToolCount, reinterpret_cast<VkPhysicalDeviceToolProperties *>( pToolProperties ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename PhysicalDeviceToolPropertiesAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE |
| typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator>>::type |
| PhysicalDevice::getToolProperties( Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceToolProperties && |
| "Function <vkGetPhysicalDeviceToolProperties> requires <VK_EXT_tooling_info> or <VK_VERSION_1_3>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator> toolProperties; |
| uint32_t toolCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPhysicalDeviceToolProperties( m_physicalDevice, &toolCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && toolCount ) |
| { |
| toolProperties.resize( toolCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetPhysicalDeviceToolProperties( m_physicalDevice, &toolCount, reinterpret_cast<VkPhysicalDeviceToolProperties *>( toolProperties.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getToolProperties" ); |
| VULKAN_HPP_ASSERT( toolCount <= toolProperties.size() ); |
| if ( toolCount < toolProperties.size() ) |
| { |
| toolProperties.resize( toolCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( toolProperties ) ); |
| } |
| |
| template < |
| typename PhysicalDeviceToolPropertiesAllocator, |
| typename Dispatch, |
| typename std::enable_if<std::is_same<typename PhysicalDeviceToolPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties>::value, |
| int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE |
| typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator>>::type |
| PhysicalDevice::getToolProperties( PhysicalDeviceToolPropertiesAllocator & physicalDeviceToolPropertiesAllocator, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceToolProperties && |
| "Function <vkGetPhysicalDeviceToolProperties> requires <VK_EXT_tooling_info> or <VK_VERSION_1_3>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator> toolProperties( |
| physicalDeviceToolPropertiesAllocator ); |
| uint32_t toolCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPhysicalDeviceToolProperties( m_physicalDevice, &toolCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && toolCount ) |
| { |
| toolProperties.resize( toolCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetPhysicalDeviceToolProperties( m_physicalDevice, &toolCount, reinterpret_cast<VkPhysicalDeviceToolProperties *>( toolProperties.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getToolProperties" ); |
| VULKAN_HPP_ASSERT( toolCount <= toolProperties.size() ); |
| if ( toolCount < toolProperties.size() ) |
| { |
| toolProperties.resize( toolCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( toolProperties ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createPrivateDataSlot( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::PrivateDataSlot * pPrivateDataSlot, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreatePrivateDataSlot( m_device, |
| reinterpret_cast<const VkPrivateDataSlotCreateInfo *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkPrivateDataSlot *>( pPrivateDataSlot ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::PrivateDataSlot>::type |
| Device::createPrivateDataSlot( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreatePrivateDataSlot && "Function <vkCreatePrivateDataSlot> requires <VK_EXT_private_data> or <VK_VERSION_1_3>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreatePrivateDataSlot( m_device, |
| reinterpret_cast<const VkPrivateDataSlotCreateInfo *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkPrivateDataSlot *>( &privateDataSlot ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createPrivateDataSlot" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( privateDataSlot ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PrivateDataSlot, Dispatch>>::type |
| Device::createPrivateDataSlotUnique( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreatePrivateDataSlot && "Function <vkCreatePrivateDataSlot> requires <VK_EXT_private_data> or <VK_VERSION_1_3>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreatePrivateDataSlot( m_device, |
| reinterpret_cast<const VkPrivateDataSlotCreateInfo *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkPrivateDataSlot *>( &privateDataSlot ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createPrivateDataSlotUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::PrivateDataSlot, Dispatch>( privateDataSlot, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyPrivateDataSlot( VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyPrivateDataSlot( m_device, static_cast<VkPrivateDataSlot>( privateDataSlot ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyPrivateDataSlot( VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyPrivateDataSlot && "Function <vkDestroyPrivateDataSlot> requires <VK_EXT_private_data> or <VK_VERSION_1_3>" ); |
| # endif |
| |
| d.vkDestroyPrivateDataSlot( |
| m_device, |
| static_cast<VkPrivateDataSlot>( privateDataSlot ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyPrivateDataSlot( m_device, static_cast<VkPrivateDataSlot>( privateDataSlot ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyPrivateDataSlot && "Function <vkDestroyPrivateDataSlot> requires <VK_EXT_private_data> or <VK_VERSION_1_3>" ); |
| # endif |
| |
| d.vkDestroyPrivateDataSlot( |
| m_device, |
| static_cast<VkPrivateDataSlot>( privateDataSlot ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::setPrivateData( VULKAN_HPP_NAMESPACE::ObjectType objectType_, |
| uint64_t objectHandle, |
| VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, |
| uint64_t data, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( |
| d.vkSetPrivateData( m_device, static_cast<VkObjectType>( objectType_ ), objectHandle, static_cast<VkPrivateDataSlot>( privateDataSlot ), data ) ); |
| } |
| #else |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::setPrivateData( VULKAN_HPP_NAMESPACE::ObjectType objectType_, |
| uint64_t objectHandle, |
| VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, |
| uint64_t data, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkSetPrivateData && "Function <vkSetPrivateData> requires <VK_EXT_private_data> or <VK_VERSION_1_3>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkSetPrivateData( m_device, static_cast<VkObjectType>( objectType_ ), objectHandle, static_cast<VkPrivateDataSlot>( privateDataSlot ), data ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setPrivateData" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::getPrivateData( VULKAN_HPP_NAMESPACE::ObjectType objectType_, |
| uint64_t objectHandle, |
| VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, |
| uint64_t * pData, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetPrivateData( m_device, static_cast<VkObjectType>( objectType_ ), objectHandle, static_cast<VkPrivateDataSlot>( privateDataSlot ), pData ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t Device::getPrivateData( VULKAN_HPP_NAMESPACE::ObjectType objectType_, |
| uint64_t objectHandle, |
| VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPrivateData && "Function <vkGetPrivateData> requires <VK_EXT_private_data> or <VK_VERSION_1_3>" ); |
| # endif |
| |
| uint64_t data; |
| d.vkGetPrivateData( m_device, static_cast<VkObjectType>( objectType_ ), objectHandle, static_cast<VkPrivateDataSlot>( privateDataSlot ), &data ); |
| |
| return data; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setEvent2( VULKAN_HPP_NAMESPACE::Event event, |
| const VULKAN_HPP_NAMESPACE::DependencyInfo * pDependencyInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetEvent2( m_commandBuffer, static_cast<VkEvent>( event ), reinterpret_cast<const VkDependencyInfo *>( pDependencyInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setEvent2( VULKAN_HPP_NAMESPACE::Event event, |
| const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdSetEvent2 && "Function <vkCmdSetEvent2> requires <VK_KHR_synchronization2> or <VK_VERSION_1_3>" ); |
| # endif |
| |
| d.vkCmdSetEvent2( m_commandBuffer, static_cast<VkEvent>( event ), reinterpret_cast<const VkDependencyInfo *>( &dependencyInfo ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::resetEvent2( VULKAN_HPP_NAMESPACE::Event event, |
| VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stageMask, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdResetEvent2( m_commandBuffer, static_cast<VkEvent>( event ), static_cast<VkPipelineStageFlags2>( stageMask ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::waitEvents2( uint32_t eventCount, |
| const VULKAN_HPP_NAMESPACE::Event * pEvents, |
| const VULKAN_HPP_NAMESPACE::DependencyInfo * pDependencyInfos, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdWaitEvents2( |
| m_commandBuffer, eventCount, reinterpret_cast<const VkEvent *>( pEvents ), reinterpret_cast<const VkDependencyInfo *>( pDependencyInfos ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::waitEvents2( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const & events, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DependencyInfo> const & dependencyInfos, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdWaitEvents2 && "Function <vkCmdWaitEvents2> requires <VK_KHR_synchronization2> or <VK_VERSION_1_3>" ); |
| # endif |
| # ifdef VULKAN_HPP_NO_EXCEPTIONS |
| VULKAN_HPP_ASSERT( events.size() == dependencyInfos.size() ); |
| # else |
| if ( events.size() != dependencyInfos.size() ) |
| { |
| throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::waitEvents2: events.size() != dependencyInfos.size()" ); |
| } |
| # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ |
| |
| d.vkCmdWaitEvents2( m_commandBuffer, |
| events.size(), |
| reinterpret_cast<const VkEvent *>( events.data() ), |
| reinterpret_cast<const VkDependencyInfo *>( dependencyInfos.data() ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier2( const VULKAN_HPP_NAMESPACE::DependencyInfo * pDependencyInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdPipelineBarrier2( m_commandBuffer, reinterpret_cast<const VkDependencyInfo *>( pDependencyInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier2( const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdPipelineBarrier2 && "Function <vkCmdPipelineBarrier2> requires <VK_KHR_synchronization2> or <VK_VERSION_1_3>" ); |
| # endif |
| |
| d.vkCmdPipelineBarrier2( m_commandBuffer, reinterpret_cast<const VkDependencyInfo *>( &dependencyInfo ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::writeTimestamp2( VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stage, |
| VULKAN_HPP_NAMESPACE::QueryPool queryPool, |
| uint32_t query, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdWriteTimestamp2( m_commandBuffer, static_cast<VkPipelineStageFlags2>( stage ), static_cast<VkQueryPool>( queryPool ), query ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Queue::submit2( uint32_t submitCount, |
| const VULKAN_HPP_NAMESPACE::SubmitInfo2 * pSubmits, |
| VULKAN_HPP_NAMESPACE::Fence fence, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkQueueSubmit2( m_queue, submitCount, reinterpret_cast<const VkSubmitInfo2 *>( pSubmits ), static_cast<VkFence>( fence ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type Queue::submit2( |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo2> const & submits, VULKAN_HPP_NAMESPACE::Fence fence, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkQueueSubmit2 && "Function <vkQueueSubmit2> requires <VK_KHR_synchronization2> or <VK_VERSION_1_3>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkQueueSubmit2( m_queue, submits.size(), reinterpret_cast<const VkSubmitInfo2 *>( submits.data() ), static_cast<VkFence>( fence ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::submit2" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::copyBuffer2( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 * pCopyBufferInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdCopyBuffer2( m_commandBuffer, reinterpret_cast<const VkCopyBufferInfo2 *>( pCopyBufferInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::copyBuffer2( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 & copyBufferInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdCopyBuffer2 && "Function <vkCmdCopyBuffer2> requires <VK_KHR_copy_commands2> or <VK_VERSION_1_3>" ); |
| # endif |
| |
| d.vkCmdCopyBuffer2( m_commandBuffer, reinterpret_cast<const VkCopyBufferInfo2 *>( ©BufferInfo ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::copyImage2( const VULKAN_HPP_NAMESPACE::CopyImageInfo2 * pCopyImageInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdCopyImage2( m_commandBuffer, reinterpret_cast<const VkCopyImageInfo2 *>( pCopyImageInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::copyImage2( const VULKAN_HPP_NAMESPACE::CopyImageInfo2 & copyImageInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdCopyImage2 && "Function <vkCmdCopyImage2> requires <VK_KHR_copy_commands2> or <VK_VERSION_1_3>" ); |
| # endif |
| |
| d.vkCmdCopyImage2( m_commandBuffer, reinterpret_cast<const VkCopyImageInfo2 *>( ©ImageInfo ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage2( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 * pCopyBufferToImageInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdCopyBufferToImage2( m_commandBuffer, reinterpret_cast<const VkCopyBufferToImageInfo2 *>( pCopyBufferToImageInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage2( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 & copyBufferToImageInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdCopyBufferToImage2 && "Function <vkCmdCopyBufferToImage2> requires <VK_KHR_copy_commands2> or <VK_VERSION_1_3>" ); |
| # endif |
| |
| d.vkCmdCopyBufferToImage2( m_commandBuffer, reinterpret_cast<const VkCopyBufferToImageInfo2 *>( ©BufferToImageInfo ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer2( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 * pCopyImageToBufferInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdCopyImageToBuffer2( m_commandBuffer, reinterpret_cast<const VkCopyImageToBufferInfo2 *>( pCopyImageToBufferInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer2( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 & copyImageToBufferInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdCopyImageToBuffer2 && "Function <vkCmdCopyImageToBuffer2> requires <VK_KHR_copy_commands2> or <VK_VERSION_1_3>" ); |
| # endif |
| |
| d.vkCmdCopyImageToBuffer2( m_commandBuffer, reinterpret_cast<const VkCopyImageToBufferInfo2 *>( ©ImageToBufferInfo ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::blitImage2( const VULKAN_HPP_NAMESPACE::BlitImageInfo2 * pBlitImageInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdBlitImage2( m_commandBuffer, reinterpret_cast<const VkBlitImageInfo2 *>( pBlitImageInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::blitImage2( const VULKAN_HPP_NAMESPACE::BlitImageInfo2 & blitImageInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdBlitImage2 && "Function <vkCmdBlitImage2> requires <VK_KHR_copy_commands2> or <VK_VERSION_1_3>" ); |
| # endif |
| |
| d.vkCmdBlitImage2( m_commandBuffer, reinterpret_cast<const VkBlitImageInfo2 *>( &blitImageInfo ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::resolveImage2( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 * pResolveImageInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdResolveImage2( m_commandBuffer, reinterpret_cast<const VkResolveImageInfo2 *>( pResolveImageInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::resolveImage2( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 & resolveImageInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdResolveImage2 && "Function <vkCmdResolveImage2> requires <VK_KHR_copy_commands2> or <VK_VERSION_1_3>" ); |
| # endif |
| |
| d.vkCmdResolveImage2( m_commandBuffer, reinterpret_cast<const VkResolveImageInfo2 *>( &resolveImageInfo ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::beginRendering( const VULKAN_HPP_NAMESPACE::RenderingInfo * pRenderingInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdBeginRendering( m_commandBuffer, reinterpret_cast<const VkRenderingInfo *>( pRenderingInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::beginRendering( const VULKAN_HPP_NAMESPACE::RenderingInfo & renderingInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdBeginRendering && "Function <vkCmdBeginRendering> requires <VK_KHR_dynamic_rendering> or <VK_VERSION_1_3>" ); |
| # endif |
| |
| d.vkCmdBeginRendering( m_commandBuffer, reinterpret_cast<const VkRenderingInfo *>( &renderingInfo ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::endRendering( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdEndRendering( m_commandBuffer ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setCullMode( VULKAN_HPP_NAMESPACE::CullModeFlags cullMode, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetCullMode( m_commandBuffer, static_cast<VkCullModeFlags>( cullMode ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setFrontFace( VULKAN_HPP_NAMESPACE::FrontFace frontFace, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetFrontFace( m_commandBuffer, static_cast<VkFrontFace>( frontFace ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setPrimitiveTopology( VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetPrimitiveTopology( m_commandBuffer, static_cast<VkPrimitiveTopology>( primitiveTopology ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setViewportWithCount( uint32_t viewportCount, |
| const VULKAN_HPP_NAMESPACE::Viewport * pViewports, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetViewportWithCount( m_commandBuffer, viewportCount, reinterpret_cast<const VkViewport *>( pViewports ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setViewportWithCount( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdSetViewportWithCount && |
| "Function <vkCmdSetViewportWithCount> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" ); |
| # endif |
| |
| d.vkCmdSetViewportWithCount( m_commandBuffer, viewports.size(), reinterpret_cast<const VkViewport *>( viewports.data() ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void |
| CommandBuffer::setScissorWithCount( uint32_t scissorCount, const VULKAN_HPP_NAMESPACE::Rect2D * pScissors, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetScissorWithCount( m_commandBuffer, scissorCount, reinterpret_cast<const VkRect2D *>( pScissors ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setScissorWithCount( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdSetScissorWithCount && |
| "Function <vkCmdSetScissorWithCount> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" ); |
| # endif |
| |
| d.vkCmdSetScissorWithCount( m_commandBuffer, scissors.size(), reinterpret_cast<const VkRect2D *>( scissors.data() ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers2( uint32_t firstBinding, |
| uint32_t bindingCount, |
| const VULKAN_HPP_NAMESPACE::Buffer * pBuffers, |
| const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets, |
| const VULKAN_HPP_NAMESPACE::DeviceSize * pSizes, |
| const VULKAN_HPP_NAMESPACE::DeviceSize * pStrides, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdBindVertexBuffers2( m_commandBuffer, |
| firstBinding, |
| bindingCount, |
| reinterpret_cast<const VkBuffer *>( pBuffers ), |
| reinterpret_cast<const VkDeviceSize *>( pOffsets ), |
| reinterpret_cast<const VkDeviceSize *>( pSizes ), |
| reinterpret_cast<const VkDeviceSize *>( pStrides ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers2( uint32_t firstBinding, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & strides, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdBindVertexBuffers2 && |
| "Function <vkCmdBindVertexBuffers2> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" ); |
| # endif |
| # ifdef VULKAN_HPP_NO_EXCEPTIONS |
| VULKAN_HPP_ASSERT( buffers.size() == offsets.size() ); |
| VULKAN_HPP_ASSERT( sizes.empty() || buffers.size() == sizes.size() ); |
| VULKAN_HPP_ASSERT( strides.empty() || buffers.size() == strides.size() ); |
| # else |
| if ( buffers.size() != offsets.size() ) |
| { |
| throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers2: buffers.size() != offsets.size()" ); |
| } |
| if ( !sizes.empty() && buffers.size() != sizes.size() ) |
| { |
| throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers2: buffers.size() != sizes.size()" ); |
| } |
| if ( !strides.empty() && buffers.size() != strides.size() ) |
| { |
| throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers2: buffers.size() != strides.size()" ); |
| } |
| # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ |
| |
| d.vkCmdBindVertexBuffers2( m_commandBuffer, |
| firstBinding, |
| buffers.size(), |
| reinterpret_cast<const VkBuffer *>( buffers.data() ), |
| reinterpret_cast<const VkDeviceSize *>( offsets.data() ), |
| reinterpret_cast<const VkDeviceSize *>( sizes.data() ), |
| reinterpret_cast<const VkDeviceSize *>( strides.data() ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setDepthTestEnable( VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetDepthTestEnable( m_commandBuffer, static_cast<VkBool32>( depthTestEnable ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setDepthWriteEnable( VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetDepthWriteEnable( m_commandBuffer, static_cast<VkBool32>( depthWriteEnable ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setDepthCompareOp( VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetDepthCompareOp( m_commandBuffer, static_cast<VkCompareOp>( depthCompareOp ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setDepthBoundsTestEnable( VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetDepthBoundsTestEnable( m_commandBuffer, static_cast<VkBool32>( depthBoundsTestEnable ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setStencilTestEnable( VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetStencilTestEnable( m_commandBuffer, static_cast<VkBool32>( stencilTestEnable ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setStencilOp( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, |
| VULKAN_HPP_NAMESPACE::StencilOp failOp, |
| VULKAN_HPP_NAMESPACE::StencilOp passOp, |
| VULKAN_HPP_NAMESPACE::StencilOp depthFailOp, |
| VULKAN_HPP_NAMESPACE::CompareOp compareOp, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetStencilOp( m_commandBuffer, |
| static_cast<VkStencilFaceFlags>( faceMask ), |
| static_cast<VkStencilOp>( failOp ), |
| static_cast<VkStencilOp>( passOp ), |
| static_cast<VkStencilOp>( depthFailOp ), |
| static_cast<VkCompareOp>( compareOp ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setRasterizerDiscardEnable( VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetRasterizerDiscardEnable( m_commandBuffer, static_cast<VkBool32>( rasterizerDiscardEnable ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setDepthBiasEnable( VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetDepthBiasEnable( m_commandBuffer, static_cast<VkBool32>( depthBiasEnable ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setPrimitiveRestartEnable( VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetPrimitiveRestartEnable( m_commandBuffer, static_cast<VkBool32>( primitiveRestartEnable ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::getBufferMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements * pInfo, |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetDeviceBufferMemoryRequirements( |
| m_device, reinterpret_cast<const VkDeviceBufferMemoryRequirements *>( pInfo ), reinterpret_cast<VkMemoryRequirements2 *>( pMemoryRequirements ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2 |
| Device::getBufferMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetDeviceBufferMemoryRequirements && |
| "Function <vkGetDeviceBufferMemoryRequirements> requires <VK_KHR_maintenance4> or <VK_VERSION_1_3>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements; |
| d.vkGetDeviceBufferMemoryRequirements( |
| m_device, reinterpret_cast<const VkDeviceBufferMemoryRequirements *>( &info ), reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) ); |
| |
| return memoryRequirements; |
| } |
| |
| template <typename X, typename Y, typename... Z, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> |
| Device::getBufferMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetDeviceBufferMemoryRequirements && |
| "Function <vkGetDeviceBufferMemoryRequirements> requires <VK_KHR_maintenance4> or <VK_VERSION_1_3>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain; |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>(); |
| d.vkGetDeviceBufferMemoryRequirements( |
| m_device, reinterpret_cast<const VkDeviceBufferMemoryRequirements *>( &info ), reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) ); |
| |
| return structureChain; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::getImageMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements * pInfo, |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetDeviceImageMemoryRequirements( |
| m_device, reinterpret_cast<const VkDeviceImageMemoryRequirements *>( pInfo ), reinterpret_cast<VkMemoryRequirements2 *>( pMemoryRequirements ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2 |
| Device::getImageMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetDeviceImageMemoryRequirements && |
| "Function <vkGetDeviceImageMemoryRequirements> requires <VK_KHR_maintenance4> or <VK_VERSION_1_3>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements; |
| d.vkGetDeviceImageMemoryRequirements( |
| m_device, reinterpret_cast<const VkDeviceImageMemoryRequirements *>( &info ), reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) ); |
| |
| return memoryRequirements; |
| } |
| |
| template <typename X, typename Y, typename... Z, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> |
| Device::getImageMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetDeviceImageMemoryRequirements && |
| "Function <vkGetDeviceImageMemoryRequirements> requires <VK_KHR_maintenance4> or <VK_VERSION_1_3>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain; |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>(); |
| d.vkGetDeviceImageMemoryRequirements( |
| m_device, reinterpret_cast<const VkDeviceImageMemoryRequirements *>( &info ), reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) ); |
| |
| return structureChain; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements * pInfo, |
| uint32_t * pSparseMemoryRequirementCount, |
| VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 * pSparseMemoryRequirements, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetDeviceImageSparseMemoryRequirements( m_device, |
| reinterpret_cast<const VkDeviceImageMemoryRequirements *>( pInfo ), |
| pSparseMemoryRequirementCount, |
| reinterpret_cast<VkSparseImageMemoryRequirements2 *>( pSparseMemoryRequirements ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename SparseImageMemoryRequirements2Allocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> |
| Device::getImageSparseMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetDeviceImageSparseMemoryRequirements && |
| "Function <vkGetDeviceImageSparseMemoryRequirements> requires <VK_KHR_maintenance4> or <VK_VERSION_1_3>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> sparseMemoryRequirements; |
| uint32_t sparseMemoryRequirementCount; |
| d.vkGetDeviceImageSparseMemoryRequirements( |
| m_device, reinterpret_cast<const VkDeviceImageMemoryRequirements *>( &info ), &sparseMemoryRequirementCount, nullptr ); |
| sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); |
| d.vkGetDeviceImageSparseMemoryRequirements( m_device, |
| reinterpret_cast<const VkDeviceImageMemoryRequirements *>( &info ), |
| &sparseMemoryRequirementCount, |
| reinterpret_cast<VkSparseImageMemoryRequirements2 *>( sparseMemoryRequirements.data() ) ); |
| |
| VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() ); |
| if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() ) |
| { |
| sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); |
| } |
| return sparseMemoryRequirements; |
| } |
| |
| template <typename SparseImageMemoryRequirements2Allocator, |
| typename Dispatch, |
| typename std::enable_if< |
| std::is_same<typename SparseImageMemoryRequirements2Allocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>::value, |
| int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> |
| Device::getImageSparseMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info, |
| SparseImageMemoryRequirements2Allocator & sparseImageMemoryRequirements2Allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetDeviceImageSparseMemoryRequirements && |
| "Function <vkGetDeviceImageSparseMemoryRequirements> requires <VK_KHR_maintenance4> or <VK_VERSION_1_3>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> sparseMemoryRequirements( |
| sparseImageMemoryRequirements2Allocator ); |
| uint32_t sparseMemoryRequirementCount; |
| d.vkGetDeviceImageSparseMemoryRequirements( |
| m_device, reinterpret_cast<const VkDeviceImageMemoryRequirements *>( &info ), &sparseMemoryRequirementCount, nullptr ); |
| sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); |
| d.vkGetDeviceImageSparseMemoryRequirements( m_device, |
| reinterpret_cast<const VkDeviceImageMemoryRequirements *>( &info ), |
| &sparseMemoryRequirementCount, |
| reinterpret_cast<VkSparseImageMemoryRequirements2 *>( sparseMemoryRequirements.data() ) ); |
| |
| VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() ); |
| if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() ) |
| { |
| sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); |
| } |
| return sparseMemoryRequirements; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_KHR_surface === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Instance::destroySurfaceKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroySurfaceKHR( m_instance, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Instance::destroySurfaceKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroySurfaceKHR && "Function <vkDestroySurfaceKHR> requires <VK_KHR_surface>" ); |
| # endif |
| |
| d.vkDestroySurfaceKHR( m_instance, |
| static_cast<VkSurfaceKHR>( surface ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Instance::destroy( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroySurfaceKHR( m_instance, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Instance::destroy( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroySurfaceKHR && "Function <vkDestroySurfaceKHR> requires <VK_KHR_surface>" ); |
| # endif |
| |
| d.vkDestroySurfaceKHR( m_instance, |
| static_cast<VkSurfaceKHR>( surface ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceSupportKHR( uint32_t queueFamilyIndex, |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface, |
| VULKAN_HPP_NAMESPACE::Bool32 * pSupported, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetPhysicalDeviceSurfaceSupportKHR( |
| m_physicalDevice, queueFamilyIndex, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkBool32 *>( pSupported ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::Bool32>::type |
| PhysicalDevice::getSurfaceSupportKHR( uint32_t queueFamilyIndex, VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfaceSupportKHR && "Function <vkGetPhysicalDeviceSurfaceSupportKHR> requires <VK_KHR_surface>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Bool32 supported; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPhysicalDeviceSurfaceSupportKHR( |
| m_physicalDevice, queueFamilyIndex, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkBool32 *>( &supported ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceSupportKHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( supported ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceCapabilitiesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, |
| VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR * pSurfaceCapabilities, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilitiesKHR( |
| m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkSurfaceCapabilitiesKHR *>( pSurfaceCapabilities ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR>::type |
| PhysicalDevice::getSurfaceCapabilitiesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfaceCapabilitiesKHR && "Function <vkGetPhysicalDeviceSurfaceCapabilitiesKHR> requires <VK_KHR_surface>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR surfaceCapabilities; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPhysicalDeviceSurfaceCapabilitiesKHR( |
| m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkSurfaceCapabilitiesKHR *>( &surfaceCapabilities ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilitiesKHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( surfaceCapabilities ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, |
| uint32_t * pSurfaceFormatCount, |
| VULKAN_HPP_NAMESPACE::SurfaceFormatKHR * pSurfaceFormats, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormatsKHR( |
| m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), pSurfaceFormatCount, reinterpret_cast<VkSurfaceFormatKHR *>( pSurfaceFormats ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename SurfaceFormatKHRAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR, SurfaceFormatKHRAllocator>>::type |
| PhysicalDevice::getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfaceFormatsKHR && "Function <vkGetPhysicalDeviceSurfaceFormatsKHR> requires <VK_KHR_surface>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR, SurfaceFormatKHRAllocator> surfaceFormats; |
| uint32_t surfaceFormatCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetPhysicalDeviceSurfaceFormatsKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &surfaceFormatCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && surfaceFormatCount ) |
| { |
| surfaceFormats.resize( surfaceFormatCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPhysicalDeviceSurfaceFormatsKHR( |
| m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &surfaceFormatCount, reinterpret_cast<VkSurfaceFormatKHR *>( surfaceFormats.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceFormatsKHR" ); |
| VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() ); |
| if ( surfaceFormatCount < surfaceFormats.size() ) |
| { |
| surfaceFormats.resize( surfaceFormatCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( surfaceFormats ) ); |
| } |
| |
| template <typename SurfaceFormatKHRAllocator, |
| typename Dispatch, |
| typename std::enable_if<std::is_same<typename SurfaceFormatKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::SurfaceFormatKHR>::value, int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR, SurfaceFormatKHRAllocator>>::type |
| PhysicalDevice::getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, |
| SurfaceFormatKHRAllocator & surfaceFormatKHRAllocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfaceFormatsKHR && "Function <vkGetPhysicalDeviceSurfaceFormatsKHR> requires <VK_KHR_surface>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR, SurfaceFormatKHRAllocator> surfaceFormats( surfaceFormatKHRAllocator ); |
| uint32_t surfaceFormatCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetPhysicalDeviceSurfaceFormatsKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &surfaceFormatCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && surfaceFormatCount ) |
| { |
| surfaceFormats.resize( surfaceFormatCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPhysicalDeviceSurfaceFormatsKHR( |
| m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &surfaceFormatCount, reinterpret_cast<VkSurfaceFormatKHR *>( surfaceFormats.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceFormatsKHR" ); |
| VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() ); |
| if ( surfaceFormatCount < surfaceFormats.size() ) |
| { |
| surfaceFormats.resize( surfaceFormatCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( surfaceFormats ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, |
| uint32_t * pPresentModeCount, |
| VULKAN_HPP_NAMESPACE::PresentModeKHR * pPresentModes, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetPhysicalDeviceSurfacePresentModesKHR( |
| m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), pPresentModeCount, reinterpret_cast<VkPresentModeKHR *>( pPresentModes ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename PresentModeKHRAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR, PresentModeKHRAllocator>>::type |
| PhysicalDevice::getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfacePresentModesKHR && "Function <vkGetPhysicalDeviceSurfacePresentModesKHR> requires <VK_KHR_surface>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR, PresentModeKHRAllocator> presentModes; |
| uint32_t presentModeCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetPhysicalDeviceSurfacePresentModesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &presentModeCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && presentModeCount ) |
| { |
| presentModes.resize( presentModeCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPhysicalDeviceSurfacePresentModesKHR( |
| m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &presentModeCount, reinterpret_cast<VkPresentModeKHR *>( presentModes.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfacePresentModesKHR" ); |
| VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() ); |
| if ( presentModeCount < presentModes.size() ) |
| { |
| presentModes.resize( presentModeCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( presentModes ) ); |
| } |
| |
| template <typename PresentModeKHRAllocator, |
| typename Dispatch, |
| typename std::enable_if<std::is_same<typename PresentModeKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::PresentModeKHR>::value, int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR, PresentModeKHRAllocator>>::type |
| PhysicalDevice::getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, |
| PresentModeKHRAllocator & presentModeKHRAllocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfacePresentModesKHR && "Function <vkGetPhysicalDeviceSurfacePresentModesKHR> requires <VK_KHR_surface>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR, PresentModeKHRAllocator> presentModes( presentModeKHRAllocator ); |
| uint32_t presentModeCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetPhysicalDeviceSurfacePresentModesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &presentModeCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && presentModeCount ) |
| { |
| presentModes.resize( presentModeCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPhysicalDeviceSurfacePresentModesKHR( |
| m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &presentModeCount, reinterpret_cast<VkPresentModeKHR *>( presentModes.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfacePresentModesKHR" ); |
| VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() ); |
| if ( presentModeCount < presentModes.size() ) |
| { |
| presentModes.resize( presentModeCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( presentModes ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_KHR_swapchain === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createSwapchainKHR( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::SwapchainKHR * pSwapchain, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateSwapchainKHR( m_device, |
| reinterpret_cast<const VkSwapchainCreateInfoKHR *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkSwapchainKHR *>( pSwapchain ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::SwapchainKHR>::type |
| Device::createSwapchainKHR( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateSwapchainKHR && "Function <vkCreateSwapchainKHR> requires <VK_KHR_swapchain>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateSwapchainKHR( m_device, |
| reinterpret_cast<const VkSwapchainCreateInfoKHR *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkSwapchainKHR *>( &swapchain ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSwapchainKHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( swapchain ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>>::type |
| Device::createSwapchainKHRUnique( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateSwapchainKHR && "Function <vkCreateSwapchainKHR> requires <VK_KHR_swapchain>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateSwapchainKHR( m_device, |
| reinterpret_cast<const VkSwapchainCreateInfoKHR *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkSwapchainKHR *>( &swapchain ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSwapchainKHRUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>( swapchain, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroySwapchainKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroySwapchainKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroySwapchainKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroySwapchainKHR && "Function <vkDestroySwapchainKHR> requires <VK_KHR_swapchain>" ); |
| # endif |
| |
| d.vkDestroySwapchainKHR( m_device, |
| static_cast<VkSwapchainKHR>( swapchain ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroySwapchainKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroySwapchainKHR && "Function <vkDestroySwapchainKHR> requires <VK_KHR_swapchain>" ); |
| # endif |
| |
| d.vkDestroySwapchainKHR( m_device, |
| static_cast<VkSwapchainKHR>( swapchain ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSwapchainImagesKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, |
| uint32_t * pSwapchainImageCount, |
| VULKAN_HPP_NAMESPACE::Image * pSwapchainImages, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( |
| d.vkGetSwapchainImagesKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), pSwapchainImageCount, reinterpret_cast<VkImage *>( pSwapchainImages ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename ImageAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::Image, ImageAllocator>>::type |
| Device::getSwapchainImagesKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetSwapchainImagesKHR && "Function <vkGetSwapchainImagesKHR> requires <VK_KHR_swapchain>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::Image, ImageAllocator> swapchainImages; |
| uint32_t swapchainImageCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetSwapchainImagesKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), &swapchainImageCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && swapchainImageCount ) |
| { |
| swapchainImages.resize( swapchainImageCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetSwapchainImagesKHR( |
| m_device, static_cast<VkSwapchainKHR>( swapchain ), &swapchainImageCount, reinterpret_cast<VkImage *>( swapchainImages.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSwapchainImagesKHR" ); |
| VULKAN_HPP_ASSERT( swapchainImageCount <= swapchainImages.size() ); |
| if ( swapchainImageCount < swapchainImages.size() ) |
| { |
| swapchainImages.resize( swapchainImageCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( swapchainImages ) ); |
| } |
| |
| template <typename ImageAllocator, |
| typename Dispatch, |
| typename std::enable_if<std::is_same<typename ImageAllocator::value_type, VULKAN_HPP_NAMESPACE::Image>::value, int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::Image, ImageAllocator>>::type |
| Device::getSwapchainImagesKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, ImageAllocator & imageAllocator, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetSwapchainImagesKHR && "Function <vkGetSwapchainImagesKHR> requires <VK_KHR_swapchain>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::Image, ImageAllocator> swapchainImages( imageAllocator ); |
| uint32_t swapchainImageCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetSwapchainImagesKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), &swapchainImageCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && swapchainImageCount ) |
| { |
| swapchainImages.resize( swapchainImageCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetSwapchainImagesKHR( |
| m_device, static_cast<VkSwapchainKHR>( swapchain ), &swapchainImageCount, reinterpret_cast<VkImage *>( swapchainImages.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSwapchainImagesKHR" ); |
| VULKAN_HPP_ASSERT( swapchainImageCount <= swapchainImages.size() ); |
| if ( swapchainImageCount < swapchainImages.size() ) |
| { |
| swapchainImages.resize( swapchainImageCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( swapchainImages ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::acquireNextImageKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, |
| uint64_t timeout, |
| VULKAN_HPP_NAMESPACE::Semaphore semaphore, |
| VULKAN_HPP_NAMESPACE::Fence fence, |
| uint32_t * pImageIndex, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkAcquireNextImageKHR( |
| m_device, static_cast<VkSwapchainKHR>( swapchain ), timeout, static_cast<VkSemaphore>( semaphore ), static_cast<VkFence>( fence ), pImageIndex ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<uint32_t> Device::acquireNextImageKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, |
| uint64_t timeout, |
| VULKAN_HPP_NAMESPACE::Semaphore semaphore, |
| VULKAN_HPP_NAMESPACE::Fence fence, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkAcquireNextImageKHR && "Function <vkAcquireNextImageKHR> requires <VK_KHR_swapchain>" ); |
| # endif |
| |
| uint32_t imageIndex; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkAcquireNextImageKHR( |
| m_device, static_cast<VkSwapchainKHR>( swapchain ), timeout, static_cast<VkSemaphore>( semaphore ), static_cast<VkFence>( fence ), &imageIndex ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, |
| VULKAN_HPP_NAMESPACE_STRING "::Device::acquireNextImageKHR", |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, |
| VULKAN_HPP_NAMESPACE::Result::eTimeout, |
| VULKAN_HPP_NAMESPACE::Result::eNotReady, |
| VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR } ); |
| |
| return ResultValue<uint32_t>( result, std::move( imageIndex ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Queue::presentKHR( const VULKAN_HPP_NAMESPACE::PresentInfoKHR * pPresentInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkQueuePresentKHR( m_queue, reinterpret_cast<const VkPresentInfoKHR *>( pPresentInfo ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result Queue::presentKHR( const VULKAN_HPP_NAMESPACE::PresentInfoKHR & presentInfo, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkQueuePresentKHR && "Function <vkQueuePresentKHR> requires <VK_KHR_swapchain>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = |
| static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkQueuePresentKHR( m_queue, reinterpret_cast<const VkPresentInfoKHR *>( &presentInfo ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( |
| result, VULKAN_HPP_NAMESPACE_STRING "::Queue::presentKHR", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR } ); |
| |
| return static_cast<VULKAN_HPP_NAMESPACE::Result>( result ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getGroupPresentCapabilitiesKHR( |
| VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR * pDeviceGroupPresentCapabilities, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( |
| d.vkGetDeviceGroupPresentCapabilitiesKHR( m_device, reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHR *>( pDeviceGroupPresentCapabilities ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR>::type |
| Device::getGroupPresentCapabilitiesKHR( Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetDeviceGroupPresentCapabilitiesKHR && |
| "Function <vkGetDeviceGroupPresentCapabilitiesKHR> requires <VK_KHR_device_group> or <VK_KHR_swapchain>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR deviceGroupPresentCapabilities; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetDeviceGroupPresentCapabilitiesKHR( m_device, reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHR *>( &deviceGroupPresentCapabilities ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getGroupPresentCapabilitiesKHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( deviceGroupPresentCapabilities ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getGroupSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, |
| VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR * pModes, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetDeviceGroupSurfacePresentModesKHR( |
| m_device, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkDeviceGroupPresentModeFlagsKHR *>( pModes ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR>::type |
| Device::getGroupSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetDeviceGroupSurfacePresentModesKHR && |
| "Function <vkGetDeviceGroupSurfacePresentModesKHR> requires <VK_KHR_device_group> or <VK_KHR_swapchain>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR modes; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetDeviceGroupSurfacePresentModesKHR( |
| m_device, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkDeviceGroupPresentModeFlagsKHR *>( &modes ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getGroupSurfacePresentModesKHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( modes ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, |
| uint32_t * pRectCount, |
| VULKAN_HPP_NAMESPACE::Rect2D * pRects, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( |
| d.vkGetPhysicalDevicePresentRectanglesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), pRectCount, reinterpret_cast<VkRect2D *>( pRects ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Rect2DAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::Rect2D, Rect2DAllocator>>::type |
| PhysicalDevice::getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDevicePresentRectanglesKHR && |
| "Function <vkGetPhysicalDevicePresentRectanglesKHR> requires <VK_KHR_device_group> or <VK_KHR_swapchain>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::Rect2D, Rect2DAllocator> rects; |
| uint32_t rectCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetPhysicalDevicePresentRectanglesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &rectCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && rectCount ) |
| { |
| rects.resize( rectCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPhysicalDevicePresentRectanglesKHR( |
| m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &rectCount, reinterpret_cast<VkRect2D *>( rects.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getPresentRectanglesKHR" ); |
| VULKAN_HPP_ASSERT( rectCount <= rects.size() ); |
| if ( rectCount < rects.size() ) |
| { |
| rects.resize( rectCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( rects ) ); |
| } |
| |
| template <typename Rect2DAllocator, |
| typename Dispatch, |
| typename std::enable_if<std::is_same<typename Rect2DAllocator::value_type, VULKAN_HPP_NAMESPACE::Rect2D>::value, int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::Rect2D, Rect2DAllocator>>::type |
| PhysicalDevice::getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Rect2DAllocator & rect2DAllocator, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDevicePresentRectanglesKHR && |
| "Function <vkGetPhysicalDevicePresentRectanglesKHR> requires <VK_KHR_device_group> or <VK_KHR_swapchain>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::Rect2D, Rect2DAllocator> rects( rect2DAllocator ); |
| uint32_t rectCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetPhysicalDevicePresentRectanglesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &rectCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && rectCount ) |
| { |
| rects.resize( rectCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPhysicalDevicePresentRectanglesKHR( |
| m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &rectCount, reinterpret_cast<VkRect2D *>( rects.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getPresentRectanglesKHR" ); |
| VULKAN_HPP_ASSERT( rectCount <= rects.size() ); |
| if ( rectCount < rects.size() ) |
| { |
| rects.resize( rectCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( rects ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::acquireNextImage2KHR( const VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR * pAcquireInfo, |
| uint32_t * pImageIndex, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkAcquireNextImage2KHR( m_device, reinterpret_cast<const VkAcquireNextImageInfoKHR *>( pAcquireInfo ), pImageIndex ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<uint32_t> Device::acquireNextImage2KHR( const VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR & acquireInfo, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkAcquireNextImage2KHR && "Function <vkAcquireNextImage2KHR> requires <VK_KHR_device_group> or <VK_KHR_swapchain>" ); |
| # endif |
| |
| uint32_t imageIndex; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkAcquireNextImage2KHR( m_device, reinterpret_cast<const VkAcquireNextImageInfoKHR *>( &acquireInfo ), &imageIndex ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, |
| VULKAN_HPP_NAMESPACE_STRING "::Device::acquireNextImage2KHR", |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, |
| VULKAN_HPP_NAMESPACE::Result::eTimeout, |
| VULKAN_HPP_NAMESPACE::Result::eNotReady, |
| VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR } ); |
| |
| return ResultValue<uint32_t>( result, std::move( imageIndex ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_KHR_display === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPropertiesKHR( uint32_t * pPropertyCount, |
| VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR * pProperties, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( |
| d.vkGetPhysicalDeviceDisplayPropertiesKHR( m_physicalDevice, pPropertyCount, reinterpret_cast<VkDisplayPropertiesKHR *>( pProperties ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename DisplayPropertiesKHRAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR, DisplayPropertiesKHRAllocator>>::type |
| PhysicalDevice::getDisplayPropertiesKHR( Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceDisplayPropertiesKHR && "Function <vkGetPhysicalDeviceDisplayPropertiesKHR> requires <VK_KHR_display>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR, DisplayPropertiesKHRAllocator> properties; |
| uint32_t propertyCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPhysicalDeviceDisplayPropertiesKHR( m_physicalDevice, &propertyCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount ) |
| { |
| properties.resize( propertyCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetPhysicalDeviceDisplayPropertiesKHR( m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayPropertiesKHR *>( properties.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPropertiesKHR" ); |
| VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); |
| if ( propertyCount < properties.size() ) |
| { |
| properties.resize( propertyCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); |
| } |
| |
| template < |
| typename DisplayPropertiesKHRAllocator, |
| typename Dispatch, |
| typename std::enable_if<std::is_same<typename DisplayPropertiesKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR>::value, int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR, DisplayPropertiesKHRAllocator>>::type |
| PhysicalDevice::getDisplayPropertiesKHR( DisplayPropertiesKHRAllocator & displayPropertiesKHRAllocator, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceDisplayPropertiesKHR && "Function <vkGetPhysicalDeviceDisplayPropertiesKHR> requires <VK_KHR_display>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR, DisplayPropertiesKHRAllocator> properties( displayPropertiesKHRAllocator ); |
| uint32_t propertyCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPhysicalDeviceDisplayPropertiesKHR( m_physicalDevice, &propertyCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount ) |
| { |
| properties.resize( propertyCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetPhysicalDeviceDisplayPropertiesKHR( m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayPropertiesKHR *>( properties.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPropertiesKHR" ); |
| VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); |
| if ( propertyCount < properties.size() ) |
| { |
| properties.resize( propertyCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlanePropertiesKHR( uint32_t * pPropertyCount, |
| VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR * pProperties, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( |
| d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR( m_physicalDevice, pPropertyCount, reinterpret_cast<VkDisplayPlanePropertiesKHR *>( pProperties ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename DisplayPlanePropertiesKHRAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE |
| typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR, DisplayPlanePropertiesKHRAllocator>>::type |
| PhysicalDevice::getDisplayPlanePropertiesKHR( Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR && "Function <vkGetPhysicalDeviceDisplayPlanePropertiesKHR> requires <VK_KHR_display>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR, DisplayPlanePropertiesKHRAllocator> properties; |
| uint32_t propertyCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR( m_physicalDevice, &propertyCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount ) |
| { |
| properties.resize( propertyCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR( |
| m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayPlanePropertiesKHR *>( properties.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlanePropertiesKHR" ); |
| VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); |
| if ( propertyCount < properties.size() ) |
| { |
| properties.resize( propertyCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); |
| } |
| |
| template < |
| typename DisplayPlanePropertiesKHRAllocator, |
| typename Dispatch, |
| typename std::enable_if<std::is_same<typename DisplayPlanePropertiesKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR>::value, |
| int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE |
| typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR, DisplayPlanePropertiesKHRAllocator>>::type |
| PhysicalDevice::getDisplayPlanePropertiesKHR( DisplayPlanePropertiesKHRAllocator & displayPlanePropertiesKHRAllocator, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR && "Function <vkGetPhysicalDeviceDisplayPlanePropertiesKHR> requires <VK_KHR_display>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR, DisplayPlanePropertiesKHRAllocator> properties( displayPlanePropertiesKHRAllocator ); |
| uint32_t propertyCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR( m_physicalDevice, &propertyCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount ) |
| { |
| properties.resize( propertyCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR( |
| m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayPlanePropertiesKHR *>( properties.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlanePropertiesKHR" ); |
| VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); |
| if ( propertyCount < properties.size() ) |
| { |
| properties.resize( propertyCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, |
| uint32_t * pDisplayCount, |
| VULKAN_HPP_NAMESPACE::DisplayKHR * pDisplays, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( |
| d.vkGetDisplayPlaneSupportedDisplaysKHR( m_physicalDevice, planeIndex, pDisplayCount, reinterpret_cast<VkDisplayKHR *>( pDisplays ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename DisplayKHRAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayKHR, DisplayKHRAllocator>>::type |
| PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetDisplayPlaneSupportedDisplaysKHR && "Function <vkGetDisplayPlaneSupportedDisplaysKHR> requires <VK_KHR_display>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::DisplayKHR, DisplayKHRAllocator> displays; |
| uint32_t displayCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetDisplayPlaneSupportedDisplaysKHR( m_physicalDevice, planeIndex, &displayCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && displayCount ) |
| { |
| displays.resize( displayCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetDisplayPlaneSupportedDisplaysKHR( m_physicalDevice, planeIndex, &displayCount, reinterpret_cast<VkDisplayKHR *>( displays.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR" ); |
| VULKAN_HPP_ASSERT( displayCount <= displays.size() ); |
| if ( displayCount < displays.size() ) |
| { |
| displays.resize( displayCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( displays ) ); |
| } |
| |
| template <typename DisplayKHRAllocator, |
| typename Dispatch, |
| typename std::enable_if<std::is_same<typename DisplayKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::DisplayKHR>::value, int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayKHR, DisplayKHRAllocator>>::type |
| PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, DisplayKHRAllocator & displayKHRAllocator, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetDisplayPlaneSupportedDisplaysKHR && "Function <vkGetDisplayPlaneSupportedDisplaysKHR> requires <VK_KHR_display>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::DisplayKHR, DisplayKHRAllocator> displays( displayKHRAllocator ); |
| uint32_t displayCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetDisplayPlaneSupportedDisplaysKHR( m_physicalDevice, planeIndex, &displayCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && displayCount ) |
| { |
| displays.resize( displayCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetDisplayPlaneSupportedDisplaysKHR( m_physicalDevice, planeIndex, &displayCount, reinterpret_cast<VkDisplayKHR *>( displays.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR" ); |
| VULKAN_HPP_ASSERT( displayCount <= displays.size() ); |
| if ( displayCount < displays.size() ) |
| { |
| displays.resize( displayCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( displays ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayModePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, |
| uint32_t * pPropertyCount, |
| VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR * pProperties, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetDisplayModePropertiesKHR( |
| m_physicalDevice, static_cast<VkDisplayKHR>( display ), pPropertyCount, reinterpret_cast<VkDisplayModePropertiesKHR *>( pProperties ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename DisplayModePropertiesKHRAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE |
| typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR, DisplayModePropertiesKHRAllocator>>::type |
| PhysicalDevice::getDisplayModePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetDisplayModePropertiesKHR && "Function <vkGetDisplayModePropertiesKHR> requires <VK_KHR_display>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR, DisplayModePropertiesKHRAllocator> properties; |
| uint32_t propertyCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetDisplayModePropertiesKHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount ) |
| { |
| properties.resize( propertyCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetDisplayModePropertiesKHR( |
| m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, reinterpret_cast<VkDisplayModePropertiesKHR *>( properties.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayModePropertiesKHR" ); |
| VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); |
| if ( propertyCount < properties.size() ) |
| { |
| properties.resize( propertyCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); |
| } |
| |
| template <typename DisplayModePropertiesKHRAllocator, |
| typename Dispatch, |
| typename std::enable_if<std::is_same<typename DisplayModePropertiesKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR>::value, |
| int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE |
| typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR, DisplayModePropertiesKHRAllocator>>::type |
| PhysicalDevice::getDisplayModePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, |
| DisplayModePropertiesKHRAllocator & displayModePropertiesKHRAllocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetDisplayModePropertiesKHR && "Function <vkGetDisplayModePropertiesKHR> requires <VK_KHR_display>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR, DisplayModePropertiesKHRAllocator> properties( displayModePropertiesKHRAllocator ); |
| uint32_t propertyCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetDisplayModePropertiesKHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount ) |
| { |
| properties.resize( propertyCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetDisplayModePropertiesKHR( |
| m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, reinterpret_cast<VkDisplayModePropertiesKHR *>( properties.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayModePropertiesKHR" ); |
| VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); |
| if ( propertyCount < properties.size() ) |
| { |
| properties.resize( propertyCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::createDisplayModeKHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, |
| const VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::DisplayModeKHR * pMode, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateDisplayModeKHR( m_physicalDevice, |
| static_cast<VkDisplayKHR>( display ), |
| reinterpret_cast<const VkDisplayModeCreateInfoKHR *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkDisplayModeKHR *>( pMode ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayModeKHR>::type |
| PhysicalDevice::createDisplayModeKHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, |
| const VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateDisplayModeKHR && "Function <vkCreateDisplayModeKHR> requires <VK_KHR_display>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::DisplayModeKHR mode; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateDisplayModeKHR( m_physicalDevice, |
| static_cast<VkDisplayKHR>( display ), |
| reinterpret_cast<const VkDisplayModeCreateInfoKHR *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkDisplayModeKHR *>( &mode ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::createDisplayModeKHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( mode ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayModeKHR, Dispatch>>::type |
| PhysicalDevice::createDisplayModeKHRUnique( VULKAN_HPP_NAMESPACE::DisplayKHR display, |
| const VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateDisplayModeKHR && "Function <vkCreateDisplayModeKHR> requires <VK_KHR_display>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::DisplayModeKHR mode; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateDisplayModeKHR( m_physicalDevice, |
| static_cast<VkDisplayKHR>( display ), |
| reinterpret_cast<const VkDisplayModeCreateInfoKHR *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkDisplayModeKHR *>( &mode ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::createDisplayModeKHRUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayModeKHR, Dispatch>( mode, ObjectDestroy<PhysicalDevice, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| PhysicalDevice::getDisplayPlaneCapabilitiesKHR( VULKAN_HPP_NAMESPACE::DisplayModeKHR mode, |
| uint32_t planeIndex, |
| VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR * pCapabilities, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetDisplayPlaneCapabilitiesKHR( |
| m_physicalDevice, static_cast<VkDisplayModeKHR>( mode ), planeIndex, reinterpret_cast<VkDisplayPlaneCapabilitiesKHR *>( pCapabilities ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR>::type |
| PhysicalDevice::getDisplayPlaneCapabilitiesKHR( VULKAN_HPP_NAMESPACE::DisplayModeKHR mode, uint32_t planeIndex, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetDisplayPlaneCapabilitiesKHR && "Function <vkGetDisplayPlaneCapabilitiesKHR> requires <VK_KHR_display>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR capabilities; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetDisplayPlaneCapabilitiesKHR( |
| m_physicalDevice, static_cast<VkDisplayModeKHR>( mode ), planeIndex, reinterpret_cast<VkDisplayPlaneCapabilitiesKHR *>( &capabilities ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneCapabilitiesKHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( capabilities ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createDisplayPlaneSurfaceKHR( const VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateDisplayPlaneSurfaceKHR( m_instance, |
| reinterpret_cast<const VkDisplaySurfaceCreateInfoKHR *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type |
| Instance::createDisplayPlaneSurfaceKHR( const VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateDisplayPlaneSurfaceKHR && "Function <vkCreateDisplayPlaneSurfaceKHR> requires <VK_KHR_display>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateDisplayPlaneSurfaceKHR( |
| m_instance, |
| reinterpret_cast<const VkDisplaySurfaceCreateInfoKHR *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkSurfaceKHR *>( &surface ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDisplayPlaneSurfaceKHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( surface ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type |
| Instance::createDisplayPlaneSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateDisplayPlaneSurfaceKHR && "Function <vkCreateDisplayPlaneSurfaceKHR> requires <VK_KHR_display>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateDisplayPlaneSurfaceKHR( |
| m_instance, |
| reinterpret_cast<const VkDisplaySurfaceCreateInfoKHR *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkSurfaceKHR *>( &surface ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDisplayPlaneSurfaceKHRUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>( surface, ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_KHR_display_swapchain === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createSharedSwapchainsKHR( uint32_t swapchainCount, |
| const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR * pCreateInfos, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::SwapchainKHR * pSwapchains, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateSharedSwapchainsKHR( m_device, |
| swapchainCount, |
| reinterpret_cast<const VkSwapchainCreateInfoKHR *>( pCreateInfos ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkSwapchainKHR *>( pSwapchains ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename SwapchainKHRAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SwapchainKHR, SwapchainKHRAllocator>>::type |
| Device::createSharedSwapchainsKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateSharedSwapchainsKHR && "Function <vkCreateSharedSwapchainsKHR> requires <VK_KHR_display_swapchain>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::SwapchainKHR, SwapchainKHRAllocator> swapchains( createInfos.size() ); |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateSharedSwapchainsKHR( |
| m_device, |
| createInfos.size(), |
| reinterpret_cast<const VkSwapchainCreateInfoKHR *>( createInfos.data() ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkSwapchainKHR *>( swapchains.data() ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( swapchains ) ); |
| } |
| |
| template <typename SwapchainKHRAllocator, |
| typename Dispatch, |
| typename std::enable_if<std::is_same<typename SwapchainKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::SwapchainKHR>::value, int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SwapchainKHR, SwapchainKHRAllocator>>::type |
| Device::createSharedSwapchainsKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| SwapchainKHRAllocator & swapchainKHRAllocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateSharedSwapchainsKHR && "Function <vkCreateSharedSwapchainsKHR> requires <VK_KHR_display_swapchain>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::SwapchainKHR, SwapchainKHRAllocator> swapchains( createInfos.size(), swapchainKHRAllocator ); |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateSharedSwapchainsKHR( |
| m_device, |
| createInfos.size(), |
| reinterpret_cast<const VkSwapchainCreateInfoKHR *>( createInfos.data() ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkSwapchainKHR *>( swapchains.data() ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( swapchains ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::SwapchainKHR>::type |
| Device::createSharedSwapchainKHR( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateSharedSwapchainsKHR && "Function <vkCreateSharedSwapchainsKHR> requires <VK_KHR_display_swapchain>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateSharedSwapchainsKHR( |
| m_device, |
| 1, |
| reinterpret_cast<const VkSwapchainCreateInfoKHR *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkSwapchainKHR *>( &swapchain ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainKHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( swapchain ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch, typename SwapchainKHRAllocator> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE |
| typename ResultValueType<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>, SwapchainKHRAllocator>>::type |
| Device::createSharedSwapchainsKHRUnique( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateSharedSwapchainsKHR && "Function <vkCreateSharedSwapchainsKHR> requires <VK_KHR_display_swapchain>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::SwapchainKHR> swapchains( createInfos.size() ); |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateSharedSwapchainsKHR( |
| m_device, |
| createInfos.size(), |
| reinterpret_cast<const VkSwapchainCreateInfoKHR *>( createInfos.data() ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkSwapchainKHR *>( swapchains.data() ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHRUnique" ); |
| std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>, SwapchainKHRAllocator> uniqueSwapchains; |
| uniqueSwapchains.reserve( createInfos.size() ); |
| ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d ); |
| for ( auto const & swapchain : swapchains ) |
| { |
| uniqueSwapchains.push_back( UniqueHandle<SwapchainKHR, Dispatch>( swapchain, deleter ) ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( uniqueSwapchains ) ); |
| } |
| |
| template <typename Dispatch, |
| typename SwapchainKHRAllocator, |
| typename std::enable_if<std::is_same<typename SwapchainKHRAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>>::value, |
| int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE |
| typename ResultValueType<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>, SwapchainKHRAllocator>>::type |
| Device::createSharedSwapchainsKHRUnique( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| SwapchainKHRAllocator & swapchainKHRAllocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateSharedSwapchainsKHR && "Function <vkCreateSharedSwapchainsKHR> requires <VK_KHR_display_swapchain>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::SwapchainKHR> swapchains( createInfos.size() ); |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateSharedSwapchainsKHR( |
| m_device, |
| createInfos.size(), |
| reinterpret_cast<const VkSwapchainCreateInfoKHR *>( createInfos.data() ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkSwapchainKHR *>( swapchains.data() ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHRUnique" ); |
| std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>, SwapchainKHRAllocator> uniqueSwapchains( swapchainKHRAllocator ); |
| uniqueSwapchains.reserve( createInfos.size() ); |
| ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d ); |
| for ( auto const & swapchain : swapchains ) |
| { |
| uniqueSwapchains.push_back( UniqueHandle<SwapchainKHR, Dispatch>( swapchain, deleter ) ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( uniqueSwapchains ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>>::type |
| Device::createSharedSwapchainKHRUnique( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateSharedSwapchainsKHR && "Function <vkCreateSharedSwapchainsKHR> requires <VK_KHR_display_swapchain>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateSharedSwapchainsKHR( |
| m_device, |
| 1, |
| reinterpret_cast<const VkSwapchainCreateInfoKHR *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkSwapchainKHR *>( &swapchain ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainKHRUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>( swapchain, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| #if defined( VK_USE_PLATFORM_XLIB_KHR ) |
| //=== VK_KHR_xlib_surface === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createXlibSurfaceKHR( const VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateXlibSurfaceKHR( m_instance, |
| reinterpret_cast<const VkXlibSurfaceCreateInfoKHR *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) ); |
| } |
| |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type |
| Instance::createXlibSurfaceKHR( const VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateXlibSurfaceKHR && "Function <vkCreateXlibSurfaceKHR> requires <VK_KHR_xlib_surface>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateXlibSurfaceKHR( m_instance, |
| reinterpret_cast<const VkXlibSurfaceCreateInfoKHR *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkSurfaceKHR *>( &surface ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createXlibSurfaceKHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( surface ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type |
| Instance::createXlibSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateXlibSurfaceKHR && "Function <vkCreateXlibSurfaceKHR> requires <VK_KHR_xlib_surface>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateXlibSurfaceKHR( m_instance, |
| reinterpret_cast<const VkXlibSurfaceCreateInfoKHR *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkSurfaceKHR *>( &surface ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createXlibSurfaceKHRUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>( surface, ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE Bool32 |
| PhysicalDevice::getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display * dpy, VisualID visualID, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Bool32>( d.vkGetPhysicalDeviceXlibPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, dpy, visualID ) ); |
| } |
| |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Bool32 |
| PhysicalDevice::getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display & dpy, VisualID visualID, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceXlibPresentationSupportKHR && |
| "Function <vkGetPhysicalDeviceXlibPresentationSupportKHR> requires <VK_KHR_xlib_surface>" ); |
| # endif |
| |
| VkBool32 result = d.vkGetPhysicalDeviceXlibPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &dpy, visualID ); |
| |
| return static_cast<VULKAN_HPP_NAMESPACE::Bool32>( result ); |
| } |
| # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| #endif /*VK_USE_PLATFORM_XLIB_KHR*/ |
| |
| #if defined( VK_USE_PLATFORM_XCB_KHR ) |
| //=== VK_KHR_xcb_surface === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createXcbSurfaceKHR( const VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateXcbSurfaceKHR( m_instance, |
| reinterpret_cast<const VkXcbSurfaceCreateInfoKHR *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) ); |
| } |
| |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type |
| Instance::createXcbSurfaceKHR( const VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateXcbSurfaceKHR && "Function <vkCreateXcbSurfaceKHR> requires <VK_KHR_xcb_surface>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateXcbSurfaceKHR( m_instance, |
| reinterpret_cast<const VkXcbSurfaceCreateInfoKHR *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkSurfaceKHR *>( &surface ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createXcbSurfaceKHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( surface ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type |
| Instance::createXcbSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateXcbSurfaceKHR && "Function <vkCreateXcbSurfaceKHR> requires <VK_KHR_xcb_surface>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateXcbSurfaceKHR( m_instance, |
| reinterpret_cast<const VkXcbSurfaceCreateInfoKHR *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkSurfaceKHR *>( &surface ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createXcbSurfaceKHRUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>( surface, ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE Bool32 PhysicalDevice::getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, |
| xcb_connection_t * connection, |
| xcb_visualid_t visual_id, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Bool32>( d.vkGetPhysicalDeviceXcbPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, connection, visual_id ) ); |
| } |
| |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Bool32 PhysicalDevice::getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, |
| xcb_connection_t & connection, |
| xcb_visualid_t visual_id, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceXcbPresentationSupportKHR && |
| "Function <vkGetPhysicalDeviceXcbPresentationSupportKHR> requires <VK_KHR_xcb_surface>" ); |
| # endif |
| |
| VkBool32 result = d.vkGetPhysicalDeviceXcbPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &connection, visual_id ); |
| |
| return static_cast<VULKAN_HPP_NAMESPACE::Bool32>( result ); |
| } |
| # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| #endif /*VK_USE_PLATFORM_XCB_KHR*/ |
| |
| #if defined( VK_USE_PLATFORM_WAYLAND_KHR ) |
| //=== VK_KHR_wayland_surface === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createWaylandSurfaceKHR( const VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateWaylandSurfaceKHR( m_instance, |
| reinterpret_cast<const VkWaylandSurfaceCreateInfoKHR *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) ); |
| } |
| |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type |
| Instance::createWaylandSurfaceKHR( const VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateWaylandSurfaceKHR && "Function <vkCreateWaylandSurfaceKHR> requires <VK_KHR_wayland_surface>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateWaylandSurfaceKHR( |
| m_instance, |
| reinterpret_cast<const VkWaylandSurfaceCreateInfoKHR *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkSurfaceKHR *>( &surface ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createWaylandSurfaceKHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( surface ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type |
| Instance::createWaylandSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateWaylandSurfaceKHR && "Function <vkCreateWaylandSurfaceKHR> requires <VK_KHR_wayland_surface>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateWaylandSurfaceKHR( |
| m_instance, |
| reinterpret_cast<const VkWaylandSurfaceCreateInfoKHR *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkSurfaceKHR *>( &surface ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createWaylandSurfaceKHRUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>( surface, ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE Bool32 PhysicalDevice::getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, |
| struct wl_display * display, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Bool32>( d.vkGetPhysicalDeviceWaylandPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, display ) ); |
| } |
| |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Bool32 |
| PhysicalDevice::getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, struct wl_display & display, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceWaylandPresentationSupportKHR && |
| "Function <vkGetPhysicalDeviceWaylandPresentationSupportKHR> requires <VK_KHR_wayland_surface>" ); |
| # endif |
| |
| VkBool32 result = d.vkGetPhysicalDeviceWaylandPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &display ); |
| |
| return static_cast<VULKAN_HPP_NAMESPACE::Bool32>( result ); |
| } |
| # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ |
| |
| #if defined( VK_USE_PLATFORM_ANDROID_KHR ) |
| //=== VK_KHR_android_surface === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createAndroidSurfaceKHR( const VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateAndroidSurfaceKHR( m_instance, |
| reinterpret_cast<const VkAndroidSurfaceCreateInfoKHR *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) ); |
| } |
| |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type |
| Instance::createAndroidSurfaceKHR( const VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateAndroidSurfaceKHR && "Function <vkCreateAndroidSurfaceKHR> requires <VK_KHR_android_surface>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateAndroidSurfaceKHR( |
| m_instance, |
| reinterpret_cast<const VkAndroidSurfaceCreateInfoKHR *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkSurfaceKHR *>( &surface ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createAndroidSurfaceKHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( surface ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type |
| Instance::createAndroidSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateAndroidSurfaceKHR && "Function <vkCreateAndroidSurfaceKHR> requires <VK_KHR_android_surface>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateAndroidSurfaceKHR( |
| m_instance, |
| reinterpret_cast<const VkAndroidSurfaceCreateInfoKHR *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkSurfaceKHR *>( &surface ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createAndroidSurfaceKHRUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>( surface, ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ |
| |
| #if defined( VK_USE_PLATFORM_WIN32_KHR ) |
| //=== VK_KHR_win32_surface === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createWin32SurfaceKHR( const VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateWin32SurfaceKHR( m_instance, |
| reinterpret_cast<const VkWin32SurfaceCreateInfoKHR *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) ); |
| } |
| |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type |
| Instance::createWin32SurfaceKHR( const VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateWin32SurfaceKHR && "Function <vkCreateWin32SurfaceKHR> requires <VK_KHR_win32_surface>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateWin32SurfaceKHR( m_instance, |
| reinterpret_cast<const VkWin32SurfaceCreateInfoKHR *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkSurfaceKHR *>( &surface ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createWin32SurfaceKHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( surface ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type |
| Instance::createWin32SurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateWin32SurfaceKHR && "Function <vkCreateWin32SurfaceKHR> requires <VK_KHR_win32_surface>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateWin32SurfaceKHR( m_instance, |
| reinterpret_cast<const VkWin32SurfaceCreateInfoKHR *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkSurfaceKHR *>( &surface ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createWin32SurfaceKHRUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>( surface, ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE Bool32 PhysicalDevice::getWin32PresentationSupportKHR( uint32_t queueFamilyIndex, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Bool32>( d.vkGetPhysicalDeviceWin32PresentationSupportKHR( m_physicalDevice, queueFamilyIndex ) ); |
| } |
| #endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| //=== VK_EXT_debug_report === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| Instance::createDebugReportCallbackEXT( const VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT * pCallback, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateDebugReportCallbackEXT( m_instance, |
| reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkDebugReportCallbackEXT *>( pCallback ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT>::type |
| Instance::createDebugReportCallbackEXT( const VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateDebugReportCallbackEXT && "Function <vkCreateDebugReportCallbackEXT> requires <VK_EXT_debug_report>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateDebugReportCallbackEXT( |
| m_instance, |
| reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkDebugReportCallbackEXT *>( &callback ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDebugReportCallbackEXT" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( callback ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT, Dispatch>>::type |
| Instance::createDebugReportCallbackEXTUnique( const VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateDebugReportCallbackEXT && "Function <vkCreateDebugReportCallbackEXT> requires <VK_EXT_debug_report>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateDebugReportCallbackEXT( |
| m_instance, |
| reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkDebugReportCallbackEXT *>( &callback ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDebugReportCallbackEXTUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT, Dispatch>( callback, ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Instance::destroyDebugReportCallbackEXT( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyDebugReportCallbackEXT( |
| m_instance, static_cast<VkDebugReportCallbackEXT>( callback ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Instance::destroyDebugReportCallbackEXT( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyDebugReportCallbackEXT && "Function <vkDestroyDebugReportCallbackEXT> requires <VK_EXT_debug_report>" ); |
| # endif |
| |
| d.vkDestroyDebugReportCallbackEXT( |
| m_instance, |
| static_cast<VkDebugReportCallbackEXT>( callback ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Instance::destroy( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyDebugReportCallbackEXT( |
| m_instance, static_cast<VkDebugReportCallbackEXT>( callback ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Instance::destroy( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyDebugReportCallbackEXT && "Function <vkDestroyDebugReportCallbackEXT> requires <VK_EXT_debug_report>" ); |
| # endif |
| |
| d.vkDestroyDebugReportCallbackEXT( |
| m_instance, |
| static_cast<VkDebugReportCallbackEXT>( callback ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Instance::debugReportMessageEXT( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT flags, |
| VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType_, |
| uint64_t object, |
| size_t location, |
| int32_t messageCode, |
| const char * pLayerPrefix, |
| const char * pMessage, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDebugReportMessageEXT( m_instance, |
| static_cast<VkDebugReportFlagsEXT>( flags ), |
| static_cast<VkDebugReportObjectTypeEXT>( objectType_ ), |
| object, |
| location, |
| messageCode, |
| pLayerPrefix, |
| pMessage ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Instance::debugReportMessageEXT( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT flags, |
| VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType_, |
| uint64_t object, |
| size_t location, |
| int32_t messageCode, |
| const std::string & layerPrefix, |
| const std::string & message, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDebugReportMessageEXT && "Function <vkDebugReportMessageEXT> requires <VK_EXT_debug_report>" ); |
| # endif |
| |
| d.vkDebugReportMessageEXT( m_instance, |
| static_cast<VkDebugReportFlagsEXT>( flags ), |
| static_cast<VkDebugReportObjectTypeEXT>( objectType_ ), |
| object, |
| location, |
| messageCode, |
| layerPrefix.c_str(), |
| message.c_str() ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_EXT_debug_marker === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::debugMarkerSetObjectTagEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT * pTagInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkDebugMarkerSetObjectTagEXT( m_device, reinterpret_cast<const VkDebugMarkerObjectTagInfoEXT *>( pTagInfo ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type |
| Device::debugMarkerSetObjectTagEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT & tagInfo, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDebugMarkerSetObjectTagEXT && "Function <vkDebugMarkerSetObjectTagEXT> requires <VK_EXT_debug_marker>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkDebugMarkerSetObjectTagEXT( m_device, reinterpret_cast<const VkDebugMarkerObjectTagInfoEXT *>( &tagInfo ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::debugMarkerSetObjectTagEXT" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::debugMarkerSetObjectNameEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT * pNameInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkDebugMarkerSetObjectNameEXT( m_device, reinterpret_cast<const VkDebugMarkerObjectNameInfoEXT *>( pNameInfo ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type |
| Device::debugMarkerSetObjectNameEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT & nameInfo, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDebugMarkerSetObjectNameEXT && "Function <vkDebugMarkerSetObjectNameEXT> requires <VK_EXT_debug_marker>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkDebugMarkerSetObjectNameEXT( m_device, reinterpret_cast<const VkDebugMarkerObjectNameInfoEXT *>( &nameInfo ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::debugMarkerSetObjectNameEXT" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::debugMarkerBeginEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT * pMarkerInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdDebugMarkerBeginEXT( m_commandBuffer, reinterpret_cast<const VkDebugMarkerMarkerInfoEXT *>( pMarkerInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::debugMarkerBeginEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT & markerInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdDebugMarkerBeginEXT && "Function <vkCmdDebugMarkerBeginEXT> requires <VK_EXT_debug_marker>" ); |
| # endif |
| |
| d.vkCmdDebugMarkerBeginEXT( m_commandBuffer, reinterpret_cast<const VkDebugMarkerMarkerInfoEXT *>( &markerInfo ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::debugMarkerEndEXT( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdDebugMarkerEndEXT( m_commandBuffer ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::debugMarkerInsertEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT * pMarkerInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdDebugMarkerInsertEXT( m_commandBuffer, reinterpret_cast<const VkDebugMarkerMarkerInfoEXT *>( pMarkerInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::debugMarkerInsertEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT & markerInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdDebugMarkerInsertEXT && "Function <vkCmdDebugMarkerInsertEXT> requires <VK_EXT_debug_marker>" ); |
| # endif |
| |
| d.vkCmdDebugMarkerInsertEXT( m_commandBuffer, reinterpret_cast<const VkDebugMarkerMarkerInfoEXT *>( &markerInfo ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_KHR_video_queue === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR * pVideoProfile, |
| VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR * pCapabilities, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetPhysicalDeviceVideoCapabilitiesKHR( |
| m_physicalDevice, reinterpret_cast<const VkVideoProfileInfoKHR *>( pVideoProfile ), reinterpret_cast<VkVideoCapabilitiesKHR *>( pCapabilities ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR>::type |
| PhysicalDevice::getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR & videoProfile, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceVideoCapabilitiesKHR && "Function <vkGetPhysicalDeviceVideoCapabilitiesKHR> requires <VK_KHR_video_queue>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR capabilities; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPhysicalDeviceVideoCapabilitiesKHR( |
| m_physicalDevice, reinterpret_cast<const VkVideoProfileInfoKHR *>( &videoProfile ), reinterpret_cast<VkVideoCapabilitiesKHR *>( &capabilities ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoCapabilitiesKHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( capabilities ) ); |
| } |
| |
| template <typename X, typename Y, typename... Z, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>>::type |
| PhysicalDevice::getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR & videoProfile, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceVideoCapabilitiesKHR && "Function <vkGetPhysicalDeviceVideoCapabilitiesKHR> requires <VK_KHR_video_queue>" ); |
| # endif |
| |
| StructureChain<X, Y, Z...> structureChain; |
| VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR & capabilities = structureChain.template get<VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR>(); |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPhysicalDeviceVideoCapabilitiesKHR( |
| m_physicalDevice, reinterpret_cast<const VkVideoProfileInfoKHR *>( &videoProfile ), reinterpret_cast<VkVideoCapabilitiesKHR *>( &capabilities ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoCapabilitiesKHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( structureChain ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| PhysicalDevice::getVideoFormatPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR * pVideoFormatInfo, |
| uint32_t * pVideoFormatPropertyCount, |
| VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR * pVideoFormatProperties, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetPhysicalDeviceVideoFormatPropertiesKHR( m_physicalDevice, |
| reinterpret_cast<const VkPhysicalDeviceVideoFormatInfoKHR *>( pVideoFormatInfo ), |
| pVideoFormatPropertyCount, |
| reinterpret_cast<VkVideoFormatPropertiesKHR *>( pVideoFormatProperties ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename VideoFormatPropertiesKHRAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE |
| typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR, VideoFormatPropertiesKHRAllocator>>::type |
| PhysicalDevice::getVideoFormatPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceVideoFormatPropertiesKHR && |
| "Function <vkGetPhysicalDeviceVideoFormatPropertiesKHR> requires <VK_KHR_video_queue>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR, VideoFormatPropertiesKHRAllocator> videoFormatProperties; |
| uint32_t videoFormatPropertyCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPhysicalDeviceVideoFormatPropertiesKHR( |
| m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceVideoFormatInfoKHR *>( &videoFormatInfo ), &videoFormatPropertyCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && videoFormatPropertyCount ) |
| { |
| videoFormatProperties.resize( videoFormatPropertyCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetPhysicalDeviceVideoFormatPropertiesKHR( m_physicalDevice, |
| reinterpret_cast<const VkPhysicalDeviceVideoFormatInfoKHR *>( &videoFormatInfo ), |
| &videoFormatPropertyCount, |
| reinterpret_cast<VkVideoFormatPropertiesKHR *>( videoFormatProperties.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoFormatPropertiesKHR" ); |
| VULKAN_HPP_ASSERT( videoFormatPropertyCount <= videoFormatProperties.size() ); |
| if ( videoFormatPropertyCount < videoFormatProperties.size() ) |
| { |
| videoFormatProperties.resize( videoFormatPropertyCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( videoFormatProperties ) ); |
| } |
| |
| template <typename VideoFormatPropertiesKHRAllocator, |
| typename Dispatch, |
| typename std::enable_if<std::is_same<typename VideoFormatPropertiesKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR>::value, |
| int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE |
| typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR, VideoFormatPropertiesKHRAllocator>>::type |
| PhysicalDevice::getVideoFormatPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo, |
| VideoFormatPropertiesKHRAllocator & videoFormatPropertiesKHRAllocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceVideoFormatPropertiesKHR && |
| "Function <vkGetPhysicalDeviceVideoFormatPropertiesKHR> requires <VK_KHR_video_queue>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR, VideoFormatPropertiesKHRAllocator> videoFormatProperties( videoFormatPropertiesKHRAllocator ); |
| uint32_t videoFormatPropertyCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPhysicalDeviceVideoFormatPropertiesKHR( |
| m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceVideoFormatInfoKHR *>( &videoFormatInfo ), &videoFormatPropertyCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && videoFormatPropertyCount ) |
| { |
| videoFormatProperties.resize( videoFormatPropertyCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetPhysicalDeviceVideoFormatPropertiesKHR( m_physicalDevice, |
| reinterpret_cast<const VkPhysicalDeviceVideoFormatInfoKHR *>( &videoFormatInfo ), |
| &videoFormatPropertyCount, |
| reinterpret_cast<VkVideoFormatPropertiesKHR *>( videoFormatProperties.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoFormatPropertiesKHR" ); |
| VULKAN_HPP_ASSERT( videoFormatPropertyCount <= videoFormatProperties.size() ); |
| if ( videoFormatPropertyCount < videoFormatProperties.size() ) |
| { |
| videoFormatProperties.resize( videoFormatPropertyCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( videoFormatProperties ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createVideoSessionKHR( const VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::VideoSessionKHR * pVideoSession, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateVideoSessionKHR( m_device, |
| reinterpret_cast<const VkVideoSessionCreateInfoKHR *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkVideoSessionKHR *>( pVideoSession ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::VideoSessionKHR>::type |
| Device::createVideoSessionKHR( const VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateVideoSessionKHR && "Function <vkCreateVideoSessionKHR> requires <VK_KHR_video_queue>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateVideoSessionKHR( m_device, |
| reinterpret_cast<const VkVideoSessionCreateInfoKHR *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkVideoSessionKHR *>( &videoSession ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createVideoSessionKHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( videoSession ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::VideoSessionKHR, Dispatch>>::type |
| Device::createVideoSessionKHRUnique( const VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateVideoSessionKHR && "Function <vkCreateVideoSessionKHR> requires <VK_KHR_video_queue>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateVideoSessionKHR( m_device, |
| reinterpret_cast<const VkVideoSessionCreateInfoKHR *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkVideoSessionKHR *>( &videoSession ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createVideoSessionKHRUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::VideoSessionKHR, Dispatch>( videoSession, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyVideoSessionKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyVideoSessionKHR( m_device, static_cast<VkVideoSessionKHR>( videoSession ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyVideoSessionKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyVideoSessionKHR && "Function <vkDestroyVideoSessionKHR> requires <VK_KHR_video_queue>" ); |
| # endif |
| |
| d.vkDestroyVideoSessionKHR( |
| m_device, |
| static_cast<VkVideoSessionKHR>( videoSession ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyVideoSessionKHR( m_device, static_cast<VkVideoSessionKHR>( videoSession ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyVideoSessionKHR && "Function <vkDestroyVideoSessionKHR> requires <VK_KHR_video_queue>" ); |
| # endif |
| |
| d.vkDestroyVideoSessionKHR( |
| m_device, |
| static_cast<VkVideoSessionKHR>( videoSession ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| Device::getVideoSessionMemoryRequirementsKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession, |
| uint32_t * pMemoryRequirementsCount, |
| VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR * pMemoryRequirements, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetVideoSessionMemoryRequirementsKHR( m_device, |
| static_cast<VkVideoSessionKHR>( videoSession ), |
| pMemoryRequirementsCount, |
| reinterpret_cast<VkVideoSessionMemoryRequirementsKHR *>( pMemoryRequirements ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename VideoSessionMemoryRequirementsKHRAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE |
| typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR, VideoSessionMemoryRequirementsKHRAllocator>>::type |
| Device::getVideoSessionMemoryRequirementsKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetVideoSessionMemoryRequirementsKHR && "Function <vkGetVideoSessionMemoryRequirementsKHR> requires <VK_KHR_video_queue>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR, VideoSessionMemoryRequirementsKHRAllocator> memoryRequirements; |
| uint32_t memoryRequirementsCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetVideoSessionMemoryRequirementsKHR( m_device, static_cast<VkVideoSessionKHR>( videoSession ), &memoryRequirementsCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && memoryRequirementsCount ) |
| { |
| memoryRequirements.resize( memoryRequirementsCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetVideoSessionMemoryRequirementsKHR( m_device, |
| static_cast<VkVideoSessionKHR>( videoSession ), |
| &memoryRequirementsCount, |
| reinterpret_cast<VkVideoSessionMemoryRequirementsKHR *>( memoryRequirements.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| |
| VULKAN_HPP_ASSERT( memoryRequirementsCount <= memoryRequirements.size() ); |
| if ( memoryRequirementsCount < memoryRequirements.size() ) |
| { |
| memoryRequirements.resize( memoryRequirementsCount ); |
| } |
| return memoryRequirements; |
| } |
| |
| template <typename VideoSessionMemoryRequirementsKHRAllocator, |
| typename Dispatch, |
| typename std::enable_if< |
| std::is_same<typename VideoSessionMemoryRequirementsKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR>::value, |
| int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE |
| typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR, VideoSessionMemoryRequirementsKHRAllocator>>::type |
| Device::getVideoSessionMemoryRequirementsKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession, |
| VideoSessionMemoryRequirementsKHRAllocator & videoSessionMemoryRequirementsKHRAllocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetVideoSessionMemoryRequirementsKHR && "Function <vkGetVideoSessionMemoryRequirementsKHR> requires <VK_KHR_video_queue>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR, VideoSessionMemoryRequirementsKHRAllocator> memoryRequirements( |
| videoSessionMemoryRequirementsKHRAllocator ); |
| uint32_t memoryRequirementsCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetVideoSessionMemoryRequirementsKHR( m_device, static_cast<VkVideoSessionKHR>( videoSession ), &memoryRequirementsCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && memoryRequirementsCount ) |
| { |
| memoryRequirements.resize( memoryRequirementsCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetVideoSessionMemoryRequirementsKHR( m_device, |
| static_cast<VkVideoSessionKHR>( videoSession ), |
| &memoryRequirementsCount, |
| reinterpret_cast<VkVideoSessionMemoryRequirementsKHR *>( memoryRequirements.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| |
| VULKAN_HPP_ASSERT( memoryRequirementsCount <= memoryRequirements.size() ); |
| if ( memoryRequirementsCount < memoryRequirements.size() ) |
| { |
| memoryRequirements.resize( memoryRequirementsCount ); |
| } |
| return memoryRequirements; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| Device::bindVideoSessionMemoryKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession, |
| uint32_t bindSessionMemoryInfoCount, |
| const VULKAN_HPP_NAMESPACE::BindVideoSessionMemoryInfoKHR * pBindSessionMemoryInfos, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkBindVideoSessionMemoryKHR( m_device, |
| static_cast<VkVideoSessionKHR>( videoSession ), |
| bindSessionMemoryInfoCount, |
| reinterpret_cast<const VkBindVideoSessionMemoryInfoKHR *>( pBindSessionMemoryInfos ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::bindVideoSessionMemoryKHR( |
| VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindVideoSessionMemoryInfoKHR> const & bindSessionMemoryInfos, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkBindVideoSessionMemoryKHR && "Function <vkBindVideoSessionMemoryKHR> requires <VK_KHR_video_queue>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkBindVideoSessionMemoryKHR( m_device, |
| static_cast<VkVideoSessionKHR>( videoSession ), |
| bindSessionMemoryInfos.size(), |
| reinterpret_cast<const VkBindVideoSessionMemoryInfoKHR *>( bindSessionMemoryInfos.data() ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindVideoSessionMemoryKHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| Device::createVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR * pVideoSessionParameters, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateVideoSessionParametersKHR( m_device, |
| reinterpret_cast<const VkVideoSessionParametersCreateInfoKHR *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkVideoSessionParametersKHR *>( pVideoSessionParameters ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR>::type |
| Device::createVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateVideoSessionParametersKHR && "Function <vkCreateVideoSessionParametersKHR> requires <VK_KHR_video_queue>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateVideoSessionParametersKHR( |
| m_device, |
| reinterpret_cast<const VkVideoSessionParametersCreateInfoKHR *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkVideoSessionParametersKHR *>( &videoSessionParameters ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createVideoSessionParametersKHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( videoSessionParameters ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR, Dispatch>>::type |
| Device::createVideoSessionParametersKHRUnique( const VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateVideoSessionParametersKHR && "Function <vkCreateVideoSessionParametersKHR> requires <VK_KHR_video_queue>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateVideoSessionParametersKHR( |
| m_device, |
| reinterpret_cast<const VkVideoSessionParametersCreateInfoKHR *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkVideoSessionParametersKHR *>( &videoSessionParameters ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createVideoSessionParametersKHRUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, |
| UniqueHandle<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR, Dispatch>( |
| videoSessionParameters, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| Device::updateVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters, |
| const VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR * pUpdateInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkUpdateVideoSessionParametersKHR( m_device, |
| static_cast<VkVideoSessionParametersKHR>( videoSessionParameters ), |
| reinterpret_cast<const VkVideoSessionParametersUpdateInfoKHR *>( pUpdateInfo ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type |
| Device::updateVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters, |
| const VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR & updateInfo, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkUpdateVideoSessionParametersKHR && "Function <vkUpdateVideoSessionParametersKHR> requires <VK_KHR_video_queue>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkUpdateVideoSessionParametersKHR( m_device, |
| static_cast<VkVideoSessionParametersKHR>( videoSessionParameters ), |
| reinterpret_cast<const VkVideoSessionParametersUpdateInfoKHR *>( &updateInfo ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::updateVideoSessionParametersKHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyVideoSessionParametersKHR( |
| m_device, static_cast<VkVideoSessionParametersKHR>( videoSessionParameters ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyVideoSessionParametersKHR && "Function <vkDestroyVideoSessionParametersKHR> requires <VK_KHR_video_queue>" ); |
| # endif |
| |
| d.vkDestroyVideoSessionParametersKHR( |
| m_device, |
| static_cast<VkVideoSessionParametersKHR>( videoSessionParameters ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyVideoSessionParametersKHR( |
| m_device, static_cast<VkVideoSessionParametersKHR>( videoSessionParameters ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyVideoSessionParametersKHR && "Function <vkDestroyVideoSessionParametersKHR> requires <VK_KHR_video_queue>" ); |
| # endif |
| |
| d.vkDestroyVideoSessionParametersKHR( |
| m_device, |
| static_cast<VkVideoSessionParametersKHR>( videoSessionParameters ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::beginVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR * pBeginInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdBeginVideoCodingKHR( m_commandBuffer, reinterpret_cast<const VkVideoBeginCodingInfoKHR *>( pBeginInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::beginVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR & beginInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdBeginVideoCodingKHR && "Function <vkCmdBeginVideoCodingKHR> requires <VK_KHR_video_queue>" ); |
| # endif |
| |
| d.vkCmdBeginVideoCodingKHR( m_commandBuffer, reinterpret_cast<const VkVideoBeginCodingInfoKHR *>( &beginInfo ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::endVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR * pEndCodingInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdEndVideoCodingKHR( m_commandBuffer, reinterpret_cast<const VkVideoEndCodingInfoKHR *>( pEndCodingInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::endVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR & endCodingInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdEndVideoCodingKHR && "Function <vkCmdEndVideoCodingKHR> requires <VK_KHR_video_queue>" ); |
| # endif |
| |
| d.vkCmdEndVideoCodingKHR( m_commandBuffer, reinterpret_cast<const VkVideoEndCodingInfoKHR *>( &endCodingInfo ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::controlVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR * pCodingControlInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdControlVideoCodingKHR( m_commandBuffer, reinterpret_cast<const VkVideoCodingControlInfoKHR *>( pCodingControlInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::controlVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR & codingControlInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdControlVideoCodingKHR && "Function <vkCmdControlVideoCodingKHR> requires <VK_KHR_video_queue>" ); |
| # endif |
| |
| d.vkCmdControlVideoCodingKHR( m_commandBuffer, reinterpret_cast<const VkVideoCodingControlInfoKHR *>( &codingControlInfo ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_KHR_video_decode_queue === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::decodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR * pDecodeInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdDecodeVideoKHR( m_commandBuffer, reinterpret_cast<const VkVideoDecodeInfoKHR *>( pDecodeInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::decodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR & decodeInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdDecodeVideoKHR && "Function <vkCmdDecodeVideoKHR> requires <VK_KHR_video_decode_queue>" ); |
| # endif |
| |
| d.vkCmdDecodeVideoKHR( m_commandBuffer, reinterpret_cast<const VkVideoDecodeInfoKHR *>( &decodeInfo ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_EXT_transform_feedback === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::bindTransformFeedbackBuffersEXT( uint32_t firstBinding, |
| uint32_t bindingCount, |
| const VULKAN_HPP_NAMESPACE::Buffer * pBuffers, |
| const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets, |
| const VULKAN_HPP_NAMESPACE::DeviceSize * pSizes, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdBindTransformFeedbackBuffersEXT( m_commandBuffer, |
| firstBinding, |
| bindingCount, |
| reinterpret_cast<const VkBuffer *>( pBuffers ), |
| reinterpret_cast<const VkDeviceSize *>( pOffsets ), |
| reinterpret_cast<const VkDeviceSize *>( pSizes ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void |
| CommandBuffer::bindTransformFeedbackBuffersEXT( uint32_t firstBinding, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdBindTransformFeedbackBuffersEXT && "Function <vkCmdBindTransformFeedbackBuffersEXT> requires <VK_EXT_transform_feedback>" ); |
| # endif |
| # ifdef VULKAN_HPP_NO_EXCEPTIONS |
| VULKAN_HPP_ASSERT( buffers.size() == offsets.size() ); |
| VULKAN_HPP_ASSERT( sizes.empty() || buffers.size() == sizes.size() ); |
| # else |
| if ( buffers.size() != offsets.size() ) |
| { |
| throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindTransformFeedbackBuffersEXT: buffers.size() != offsets.size()" ); |
| } |
| if ( !sizes.empty() && buffers.size() != sizes.size() ) |
| { |
| throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindTransformFeedbackBuffersEXT: buffers.size() != sizes.size()" ); |
| } |
| # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ |
| |
| d.vkCmdBindTransformFeedbackBuffersEXT( m_commandBuffer, |
| firstBinding, |
| buffers.size(), |
| reinterpret_cast<const VkBuffer *>( buffers.data() ), |
| reinterpret_cast<const VkDeviceSize *>( offsets.data() ), |
| reinterpret_cast<const VkDeviceSize *>( sizes.data() ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::beginTransformFeedbackEXT( uint32_t firstCounterBuffer, |
| uint32_t counterBufferCount, |
| const VULKAN_HPP_NAMESPACE::Buffer * pCounterBuffers, |
| const VULKAN_HPP_NAMESPACE::DeviceSize * pCounterBufferOffsets, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdBeginTransformFeedbackEXT( m_commandBuffer, |
| firstCounterBuffer, |
| counterBufferCount, |
| reinterpret_cast<const VkBuffer *>( pCounterBuffers ), |
| reinterpret_cast<const VkDeviceSize *>( pCounterBufferOffsets ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void |
| CommandBuffer::beginTransformFeedbackEXT( uint32_t firstCounterBuffer, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & counterBuffers, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdBeginTransformFeedbackEXT && "Function <vkCmdBeginTransformFeedbackEXT> requires <VK_EXT_transform_feedback>" ); |
| # endif |
| # ifdef VULKAN_HPP_NO_EXCEPTIONS |
| VULKAN_HPP_ASSERT( counterBufferOffsets.empty() || counterBuffers.size() == counterBufferOffsets.size() ); |
| # else |
| if ( !counterBufferOffsets.empty() && counterBuffers.size() != counterBufferOffsets.size() ) |
| { |
| throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::beginTransformFeedbackEXT: counterBuffers.size() != counterBufferOffsets.size()" ); |
| } |
| # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ |
| |
| d.vkCmdBeginTransformFeedbackEXT( m_commandBuffer, |
| firstCounterBuffer, |
| counterBuffers.size(), |
| reinterpret_cast<const VkBuffer *>( counterBuffers.data() ), |
| reinterpret_cast<const VkDeviceSize *>( counterBufferOffsets.data() ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::endTransformFeedbackEXT( uint32_t firstCounterBuffer, |
| uint32_t counterBufferCount, |
| const VULKAN_HPP_NAMESPACE::Buffer * pCounterBuffers, |
| const VULKAN_HPP_NAMESPACE::DeviceSize * pCounterBufferOffsets, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdEndTransformFeedbackEXT( m_commandBuffer, |
| firstCounterBuffer, |
| counterBufferCount, |
| reinterpret_cast<const VkBuffer *>( pCounterBuffers ), |
| reinterpret_cast<const VkDeviceSize *>( pCounterBufferOffsets ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void |
| CommandBuffer::endTransformFeedbackEXT( uint32_t firstCounterBuffer, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & counterBuffers, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdEndTransformFeedbackEXT && "Function <vkCmdEndTransformFeedbackEXT> requires <VK_EXT_transform_feedback>" ); |
| # endif |
| # ifdef VULKAN_HPP_NO_EXCEPTIONS |
| VULKAN_HPP_ASSERT( counterBufferOffsets.empty() || counterBuffers.size() == counterBufferOffsets.size() ); |
| # else |
| if ( !counterBufferOffsets.empty() && counterBuffers.size() != counterBufferOffsets.size() ) |
| { |
| throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::endTransformFeedbackEXT: counterBuffers.size() != counterBufferOffsets.size()" ); |
| } |
| # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ |
| |
| d.vkCmdEndTransformFeedbackEXT( m_commandBuffer, |
| firstCounterBuffer, |
| counterBuffers.size(), |
| reinterpret_cast<const VkBuffer *>( counterBuffers.data() ), |
| reinterpret_cast<const VkDeviceSize *>( counterBufferOffsets.data() ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::beginQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool, |
| uint32_t query, |
| VULKAN_HPP_NAMESPACE::QueryControlFlags flags, |
| uint32_t index, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdBeginQueryIndexedEXT( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query, static_cast<VkQueryControlFlags>( flags ), index ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void |
| CommandBuffer::endQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query, uint32_t index, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdEndQueryIndexedEXT( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query, index ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::drawIndirectByteCountEXT( uint32_t instanceCount, |
| uint32_t firstInstance, |
| VULKAN_HPP_NAMESPACE::Buffer counterBuffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize counterBufferOffset, |
| uint32_t counterOffset, |
| uint32_t vertexStride, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdDrawIndirectByteCountEXT( m_commandBuffer, |
| instanceCount, |
| firstInstance, |
| static_cast<VkBuffer>( counterBuffer ), |
| static_cast<VkDeviceSize>( counterBufferOffset ), |
| counterOffset, |
| vertexStride ); |
| } |
| |
| //=== VK_NVX_binary_import === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createCuModuleNVX( const VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::CuModuleNVX * pModule, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateCuModuleNVX( m_device, |
| reinterpret_cast<const VkCuModuleCreateInfoNVX *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkCuModuleNVX *>( pModule ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::CuModuleNVX>::type |
| Device::createCuModuleNVX( const VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateCuModuleNVX && "Function <vkCreateCuModuleNVX> requires <VK_NVX_binary_import>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::CuModuleNVX module; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateCuModuleNVX( m_device, |
| reinterpret_cast<const VkCuModuleCreateInfoNVX *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkCuModuleNVX *>( &module ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createCuModuleNVX" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( module ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CuModuleNVX, Dispatch>>::type |
| Device::createCuModuleNVXUnique( const VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateCuModuleNVX && "Function <vkCreateCuModuleNVX> requires <VK_NVX_binary_import>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::CuModuleNVX module; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateCuModuleNVX( m_device, |
| reinterpret_cast<const VkCuModuleCreateInfoNVX *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkCuModuleNVX *>( &module ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createCuModuleNVXUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::CuModuleNVX, Dispatch>( module, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createCuFunctionNVX( const VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::CuFunctionNVX * pFunction, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateCuFunctionNVX( m_device, |
| reinterpret_cast<const VkCuFunctionCreateInfoNVX *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkCuFunctionNVX *>( pFunction ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::CuFunctionNVX>::type |
| Device::createCuFunctionNVX( const VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateCuFunctionNVX && "Function <vkCreateCuFunctionNVX> requires <VK_NVX_binary_import>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::CuFunctionNVX function; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateCuFunctionNVX( m_device, |
| reinterpret_cast<const VkCuFunctionCreateInfoNVX *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkCuFunctionNVX *>( &function ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createCuFunctionNVX" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( function ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CuFunctionNVX, Dispatch>>::type |
| Device::createCuFunctionNVXUnique( const VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateCuFunctionNVX && "Function <vkCreateCuFunctionNVX> requires <VK_NVX_binary_import>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::CuFunctionNVX function; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateCuFunctionNVX( m_device, |
| reinterpret_cast<const VkCuFunctionCreateInfoNVX *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkCuFunctionNVX *>( &function ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createCuFunctionNVXUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::CuFunctionNVX, Dispatch>( function, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyCuModuleNVX( VULKAN_HPP_NAMESPACE::CuModuleNVX module, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyCuModuleNVX( m_device, static_cast<VkCuModuleNVX>( module ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyCuModuleNVX( VULKAN_HPP_NAMESPACE::CuModuleNVX module, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyCuModuleNVX && "Function <vkDestroyCuModuleNVX> requires <VK_NVX_binary_import>" ); |
| # endif |
| |
| d.vkDestroyCuModuleNVX( m_device, |
| static_cast<VkCuModuleNVX>( module ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::CuModuleNVX module, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyCuModuleNVX( m_device, static_cast<VkCuModuleNVX>( module ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::CuModuleNVX module, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyCuModuleNVX && "Function <vkDestroyCuModuleNVX> requires <VK_NVX_binary_import>" ); |
| # endif |
| |
| d.vkDestroyCuModuleNVX( m_device, |
| static_cast<VkCuModuleNVX>( module ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyCuFunctionNVX( VULKAN_HPP_NAMESPACE::CuFunctionNVX function, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyCuFunctionNVX( m_device, static_cast<VkCuFunctionNVX>( function ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyCuFunctionNVX( VULKAN_HPP_NAMESPACE::CuFunctionNVX function, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyCuFunctionNVX && "Function <vkDestroyCuFunctionNVX> requires <VK_NVX_binary_import>" ); |
| # endif |
| |
| d.vkDestroyCuFunctionNVX( m_device, |
| static_cast<VkCuFunctionNVX>( function ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::CuFunctionNVX function, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyCuFunctionNVX( m_device, static_cast<VkCuFunctionNVX>( function ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::CuFunctionNVX function, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyCuFunctionNVX && "Function <vkDestroyCuFunctionNVX> requires <VK_NVX_binary_import>" ); |
| # endif |
| |
| d.vkDestroyCuFunctionNVX( m_device, |
| static_cast<VkCuFunctionNVX>( function ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::cuLaunchKernelNVX( const VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX * pLaunchInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdCuLaunchKernelNVX( m_commandBuffer, reinterpret_cast<const VkCuLaunchInfoNVX *>( pLaunchInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::cuLaunchKernelNVX( const VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX & launchInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdCuLaunchKernelNVX && "Function <vkCmdCuLaunchKernelNVX> requires <VK_NVX_binary_import>" ); |
| # endif |
| |
| d.vkCmdCuLaunchKernelNVX( m_commandBuffer, reinterpret_cast<const VkCuLaunchInfoNVX *>( &launchInfo ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_NVX_image_view_handle === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE uint32_t Device::getImageViewHandleNVX( const VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX * pInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return d.vkGetImageViewHandleNVX( m_device, reinterpret_cast<const VkImageViewHandleInfoNVX *>( pInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE uint32_t Device::getImageViewHandleNVX( const VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX & info, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetImageViewHandleNVX && "Function <vkGetImageViewHandleNVX> requires <VK_NVX_image_view_handle>" ); |
| # endif |
| |
| uint32_t result = d.vkGetImageViewHandleNVX( m_device, reinterpret_cast<const VkImageViewHandleInfoNVX *>( &info ) ); |
| |
| return result; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getImageViewAddressNVX( VULKAN_HPP_NAMESPACE::ImageView imageView, |
| VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX * pProperties, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( |
| d.vkGetImageViewAddressNVX( m_device, static_cast<VkImageView>( imageView ), reinterpret_cast<VkImageViewAddressPropertiesNVX *>( pProperties ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX>::type |
| Device::getImageViewAddressNVX( VULKAN_HPP_NAMESPACE::ImageView imageView, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetImageViewAddressNVX && "Function <vkGetImageViewAddressNVX> requires <VK_NVX_image_view_handle>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX properties; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetImageViewAddressNVX( m_device, static_cast<VkImageView>( imageView ), reinterpret_cast<VkImageViewAddressPropertiesNVX *>( &properties ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getImageViewAddressNVX" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_AMD_draw_indirect_count === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer buffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize offset, |
| VULKAN_HPP_NAMESPACE::Buffer countBuffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, |
| uint32_t maxDrawCount, |
| uint32_t stride, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdDrawIndirectCountAMD( m_commandBuffer, |
| static_cast<VkBuffer>( buffer ), |
| static_cast<VkDeviceSize>( offset ), |
| static_cast<VkBuffer>( countBuffer ), |
| static_cast<VkDeviceSize>( countBufferOffset ), |
| maxDrawCount, |
| stride ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer buffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize offset, |
| VULKAN_HPP_NAMESPACE::Buffer countBuffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, |
| uint32_t maxDrawCount, |
| uint32_t stride, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdDrawIndexedIndirectCountAMD( m_commandBuffer, |
| static_cast<VkBuffer>( buffer ), |
| static_cast<VkDeviceSize>( offset ), |
| static_cast<VkBuffer>( countBuffer ), |
| static_cast<VkDeviceSize>( countBufferOffset ), |
| maxDrawCount, |
| stride ); |
| } |
| |
| //=== VK_AMD_shader_info === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getShaderInfoAMD( VULKAN_HPP_NAMESPACE::Pipeline pipeline, |
| VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage, |
| VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD infoType, |
| size_t * pInfoSize, |
| void * pInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetShaderInfoAMD( m_device, |
| static_cast<VkPipeline>( pipeline ), |
| static_cast<VkShaderStageFlagBits>( shaderStage ), |
| static_cast<VkShaderInfoTypeAMD>( infoType ), |
| pInfoSize, |
| pInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Uint8_tAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type |
| Device::getShaderInfoAMD( VULKAN_HPP_NAMESPACE::Pipeline pipeline, |
| VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage, |
| VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD infoType, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetShaderInfoAMD && "Function <vkGetShaderInfoAMD> requires <VK_AMD_shader_info>" ); |
| # endif |
| |
| std::vector<uint8_t, Uint8_tAllocator> info; |
| size_t infoSize; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetShaderInfoAMD( m_device, |
| static_cast<VkPipeline>( pipeline ), |
| static_cast<VkShaderStageFlagBits>( shaderStage ), |
| static_cast<VkShaderInfoTypeAMD>( infoType ), |
| &infoSize, |
| nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && infoSize ) |
| { |
| info.resize( infoSize ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetShaderInfoAMD( m_device, |
| static_cast<VkPipeline>( pipeline ), |
| static_cast<VkShaderStageFlagBits>( shaderStage ), |
| static_cast<VkShaderInfoTypeAMD>( infoType ), |
| &infoSize, |
| reinterpret_cast<void *>( info.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getShaderInfoAMD" ); |
| VULKAN_HPP_ASSERT( infoSize <= info.size() ); |
| if ( infoSize < info.size() ) |
| { |
| info.resize( infoSize ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( info ) ); |
| } |
| |
| template <typename Uint8_tAllocator, |
| typename Dispatch, |
| typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type |
| Device::getShaderInfoAMD( VULKAN_HPP_NAMESPACE::Pipeline pipeline, |
| VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage, |
| VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD infoType, |
| Uint8_tAllocator & uint8_tAllocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetShaderInfoAMD && "Function <vkGetShaderInfoAMD> requires <VK_AMD_shader_info>" ); |
| # endif |
| |
| std::vector<uint8_t, Uint8_tAllocator> info( uint8_tAllocator ); |
| size_t infoSize; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetShaderInfoAMD( m_device, |
| static_cast<VkPipeline>( pipeline ), |
| static_cast<VkShaderStageFlagBits>( shaderStage ), |
| static_cast<VkShaderInfoTypeAMD>( infoType ), |
| &infoSize, |
| nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && infoSize ) |
| { |
| info.resize( infoSize ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetShaderInfoAMD( m_device, |
| static_cast<VkPipeline>( pipeline ), |
| static_cast<VkShaderStageFlagBits>( shaderStage ), |
| static_cast<VkShaderInfoTypeAMD>( infoType ), |
| &infoSize, |
| reinterpret_cast<void *>( info.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getShaderInfoAMD" ); |
| VULKAN_HPP_ASSERT( infoSize <= info.size() ); |
| if ( infoSize < info.size() ) |
| { |
| info.resize( infoSize ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( info ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_KHR_dynamic_rendering === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::beginRenderingKHR( const VULKAN_HPP_NAMESPACE::RenderingInfo * pRenderingInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdBeginRenderingKHR( m_commandBuffer, reinterpret_cast<const VkRenderingInfo *>( pRenderingInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::beginRenderingKHR( const VULKAN_HPP_NAMESPACE::RenderingInfo & renderingInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdBeginRenderingKHR && "Function <vkCmdBeginRenderingKHR> requires <VK_KHR_dynamic_rendering> or <VK_VERSION_1_3>" ); |
| # endif |
| |
| d.vkCmdBeginRenderingKHR( m_commandBuffer, reinterpret_cast<const VkRenderingInfo *>( &renderingInfo ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::endRenderingKHR( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdEndRenderingKHR( m_commandBuffer ); |
| } |
| |
| #if defined( VK_USE_PLATFORM_GGP ) |
| //=== VK_GGP_stream_descriptor_surface === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| Instance::createStreamDescriptorSurfaceGGP( const VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateStreamDescriptorSurfaceGGP( m_instance, |
| reinterpret_cast<const VkStreamDescriptorSurfaceCreateInfoGGP *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) ); |
| } |
| |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type |
| Instance::createStreamDescriptorSurfaceGGP( const VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateStreamDescriptorSurfaceGGP && "Function <vkCreateStreamDescriptorSurfaceGGP> requires <VK_GGP_stream_descriptor_surface>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateStreamDescriptorSurfaceGGP( |
| m_instance, |
| reinterpret_cast<const VkStreamDescriptorSurfaceCreateInfoGGP *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkSurfaceKHR *>( &surface ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createStreamDescriptorSurfaceGGP" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( surface ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type |
| Instance::createStreamDescriptorSurfaceGGPUnique( const VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateStreamDescriptorSurfaceGGP && "Function <vkCreateStreamDescriptorSurfaceGGP> requires <VK_GGP_stream_descriptor_surface>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateStreamDescriptorSurfaceGGP( |
| m_instance, |
| reinterpret_cast<const VkStreamDescriptorSurfaceCreateInfoGGP *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkSurfaceKHR *>( &surface ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createStreamDescriptorSurfaceGGPUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>( surface, ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| #endif /*VK_USE_PLATFORM_GGP*/ |
| |
| //=== VK_NV_external_memory_capabilities === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| PhysicalDevice::getExternalImageFormatPropertiesNV( VULKAN_HPP_NAMESPACE::Format format, |
| VULKAN_HPP_NAMESPACE::ImageType type, |
| VULKAN_HPP_NAMESPACE::ImageTiling tiling, |
| VULKAN_HPP_NAMESPACE::ImageUsageFlags usage, |
| VULKAN_HPP_NAMESPACE::ImageCreateFlags flags, |
| VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV externalHandleType, |
| VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV * pExternalImageFormatProperties, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( |
| d.vkGetPhysicalDeviceExternalImageFormatPropertiesNV( m_physicalDevice, |
| static_cast<VkFormat>( format ), |
| static_cast<VkImageType>( type ), |
| static_cast<VkImageTiling>( tiling ), |
| static_cast<VkImageUsageFlags>( usage ), |
| static_cast<VkImageCreateFlags>( flags ), |
| static_cast<VkExternalMemoryHandleTypeFlagsNV>( externalHandleType ), |
| reinterpret_cast<VkExternalImageFormatPropertiesNV *>( pExternalImageFormatProperties ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV>::type |
| PhysicalDevice::getExternalImageFormatPropertiesNV( VULKAN_HPP_NAMESPACE::Format format, |
| VULKAN_HPP_NAMESPACE::ImageType type, |
| VULKAN_HPP_NAMESPACE::ImageTiling tiling, |
| VULKAN_HPP_NAMESPACE::ImageUsageFlags usage, |
| VULKAN_HPP_NAMESPACE::ImageCreateFlags flags, |
| VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV externalHandleType, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceExternalImageFormatPropertiesNV && |
| "Function <vkGetPhysicalDeviceExternalImageFormatPropertiesNV> requires <VK_NV_external_memory_capabilities>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV externalImageFormatProperties; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetPhysicalDeviceExternalImageFormatPropertiesNV( m_physicalDevice, |
| static_cast<VkFormat>( format ), |
| static_cast<VkImageType>( type ), |
| static_cast<VkImageTiling>( tiling ), |
| static_cast<VkImageUsageFlags>( usage ), |
| static_cast<VkImageCreateFlags>( flags ), |
| static_cast<VkExternalMemoryHandleTypeFlagsNV>( externalHandleType ), |
| reinterpret_cast<VkExternalImageFormatPropertiesNV *>( &externalImageFormatProperties ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getExternalImageFormatPropertiesNV" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( externalImageFormatProperties ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| #if defined( VK_USE_PLATFORM_WIN32_KHR ) |
| //=== VK_NV_external_memory_win32 === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getMemoryWin32HandleNV( VULKAN_HPP_NAMESPACE::DeviceMemory memory, |
| VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleType, |
| HANDLE * pHandle, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( |
| d.vkGetMemoryWin32HandleNV( m_device, static_cast<VkDeviceMemory>( memory ), static_cast<VkExternalMemoryHandleTypeFlagsNV>( handleType ), pHandle ) ); |
| } |
| |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<HANDLE>::type Device::getMemoryWin32HandleNV( |
| VULKAN_HPP_NAMESPACE::DeviceMemory memory, VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleType, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetMemoryWin32HandleNV && "Function <vkGetMemoryWin32HandleNV> requires <VK_NV_external_memory_win32>" ); |
| # endif |
| |
| HANDLE handle; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetMemoryWin32HandleNV( m_device, static_cast<VkDeviceMemory>( memory ), static_cast<VkExternalMemoryHandleTypeFlagsNV>( handleType ), &handle ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryWin32HandleNV" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( handle ) ); |
| } |
| # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| #endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| //=== VK_KHR_get_physical_device_properties2 === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void PhysicalDevice::getFeatures2KHR( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 * pFeatures, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetPhysicalDeviceFeatures2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2 *>( pFeatures ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 |
| PhysicalDevice::getFeatures2KHR( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceFeatures2KHR && |
| "Function <vkGetPhysicalDeviceFeatures2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 features; |
| d.vkGetPhysicalDeviceFeatures2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2 *>( &features ) ); |
| |
| return features; |
| } |
| |
| template <typename X, typename Y, typename... Z, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> |
| PhysicalDevice::getFeatures2KHR( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceFeatures2KHR && |
| "Function <vkGetPhysicalDeviceFeatures2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain; |
| VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 & features = structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2>(); |
| d.vkGetPhysicalDeviceFeatures2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2 *>( &features ) ); |
| |
| return structureChain; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void PhysicalDevice::getProperties2KHR( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 * pProperties, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetPhysicalDeviceProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2 *>( pProperties ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 |
| PhysicalDevice::getProperties2KHR( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceProperties2KHR && |
| "Function <vkGetPhysicalDeviceProperties2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 properties; |
| d.vkGetPhysicalDeviceProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2 *>( &properties ) ); |
| |
| return properties; |
| } |
| |
| template <typename X, typename Y, typename... Z, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> |
| PhysicalDevice::getProperties2KHR( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceProperties2KHR && |
| "Function <vkGetPhysicalDeviceProperties2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain; |
| VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 & properties = structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2>(); |
| d.vkGetPhysicalDeviceProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2 *>( &properties ) ); |
| |
| return structureChain; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void PhysicalDevice::getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format, |
| VULKAN_HPP_NAMESPACE::FormatProperties2 * pFormatProperties, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetPhysicalDeviceFormatProperties2KHR( |
| m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2 *>( pFormatProperties ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::FormatProperties2 |
| PhysicalDevice::getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceFormatProperties2KHR && |
| "Function <vkGetPhysicalDeviceFormatProperties2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::FormatProperties2 formatProperties; |
| d.vkGetPhysicalDeviceFormatProperties2KHR( |
| m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2 *>( &formatProperties ) ); |
| |
| return formatProperties; |
| } |
| |
| template <typename X, typename Y, typename... Z, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> |
| PhysicalDevice::getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceFormatProperties2KHR && |
| "Function <vkGetPhysicalDeviceFormatProperties2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain; |
| VULKAN_HPP_NAMESPACE::FormatProperties2 & formatProperties = structureChain.template get<VULKAN_HPP_NAMESPACE::FormatProperties2>(); |
| d.vkGetPhysicalDeviceFormatProperties2KHR( |
| m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2 *>( &formatProperties ) ); |
| |
| return structureChain; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| PhysicalDevice::getImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 * pImageFormatInfo, |
| VULKAN_HPP_NAMESPACE::ImageFormatProperties2 * pImageFormatProperties, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2KHR( m_physicalDevice, |
| reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>( pImageFormatInfo ), |
| reinterpret_cast<VkImageFormatProperties2 *>( pImageFormatProperties ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>::type |
| PhysicalDevice::getImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceImageFormatProperties2KHR && |
| "Function <vkGetPhysicalDeviceImageFormatProperties2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::ImageFormatProperties2 imageFormatProperties; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetPhysicalDeviceImageFormatProperties2KHR( m_physicalDevice, |
| reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>( &imageFormatInfo ), |
| reinterpret_cast<VkImageFormatProperties2 *>( &imageFormatProperties ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2KHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( imageFormatProperties ) ); |
| } |
| |
| template <typename X, typename Y, typename... Z, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>>::type |
| PhysicalDevice::getImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceImageFormatProperties2KHR && |
| "Function <vkGetPhysicalDeviceImageFormatProperties2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| StructureChain<X, Y, Z...> structureChain; |
| VULKAN_HPP_NAMESPACE::ImageFormatProperties2 & imageFormatProperties = structureChain.template get<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>(); |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetPhysicalDeviceImageFormatProperties2KHR( m_physicalDevice, |
| reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>( &imageFormatInfo ), |
| reinterpret_cast<VkImageFormatProperties2 *>( &imageFormatProperties ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2KHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( structureChain ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void PhysicalDevice::getQueueFamilyProperties2KHR( uint32_t * pQueueFamilyPropertyCount, |
| VULKAN_HPP_NAMESPACE::QueueFamilyProperties2 * pQueueFamilyProperties, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( |
| m_physicalDevice, pQueueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2 *>( pQueueFamilyProperties ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename QueueFamilyProperties2Allocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2, QueueFamilyProperties2Allocator> |
| PhysicalDevice::getQueueFamilyProperties2KHR( Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyProperties2KHR && |
| "Function <vkGetPhysicalDeviceQueueFamilyProperties2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2, QueueFamilyProperties2Allocator> queueFamilyProperties; |
| uint32_t queueFamilyPropertyCount; |
| d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, nullptr ); |
| queueFamilyProperties.resize( queueFamilyPropertyCount ); |
| d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( |
| m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) ); |
| |
| VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() ); |
| if ( queueFamilyPropertyCount < queueFamilyProperties.size() ) |
| { |
| queueFamilyProperties.resize( queueFamilyPropertyCount ); |
| } |
| return queueFamilyProperties; |
| } |
| |
| template < |
| typename QueueFamilyProperties2Allocator, |
| typename Dispatch, |
| typename std::enable_if<std::is_same<typename QueueFamilyProperties2Allocator::value_type, VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>::value, int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2, QueueFamilyProperties2Allocator> |
| PhysicalDevice::getQueueFamilyProperties2KHR( QueueFamilyProperties2Allocator & queueFamilyProperties2Allocator, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyProperties2KHR && |
| "Function <vkGetPhysicalDeviceQueueFamilyProperties2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2, QueueFamilyProperties2Allocator> queueFamilyProperties( queueFamilyProperties2Allocator ); |
| uint32_t queueFamilyPropertyCount; |
| d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, nullptr ); |
| queueFamilyProperties.resize( queueFamilyPropertyCount ); |
| d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( |
| m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) ); |
| |
| VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() ); |
| if ( queueFamilyPropertyCount < queueFamilyProperties.size() ) |
| { |
| queueFamilyProperties.resize( queueFamilyPropertyCount ); |
| } |
| return queueFamilyProperties; |
| } |
| |
| template <typename StructureChain, typename StructureChainAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<StructureChain, StructureChainAllocator> |
| PhysicalDevice::getQueueFamilyProperties2KHR( Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyProperties2KHR && |
| "Function <vkGetPhysicalDeviceQueueFamilyProperties2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| std::vector<StructureChain, StructureChainAllocator> structureChains; |
| std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> queueFamilyProperties; |
| uint32_t queueFamilyPropertyCount; |
| d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, nullptr ); |
| structureChains.resize( queueFamilyPropertyCount ); |
| queueFamilyProperties.resize( queueFamilyPropertyCount ); |
| for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ ) |
| { |
| queueFamilyProperties[i].pNext = structureChains[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>().pNext; |
| } |
| d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( |
| m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) ); |
| |
| VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() ); |
| if ( queueFamilyPropertyCount < queueFamilyProperties.size() ) |
| { |
| structureChains.resize( queueFamilyPropertyCount ); |
| } |
| for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ ) |
| { |
| structureChains[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>() = queueFamilyProperties[i]; |
| } |
| return structureChains; |
| } |
| |
| template <typename StructureChain, |
| typename StructureChainAllocator, |
| typename Dispatch, |
| typename std::enable_if<std::is_same<typename StructureChainAllocator::value_type, StructureChain>::value, int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<StructureChain, StructureChainAllocator> |
| PhysicalDevice::getQueueFamilyProperties2KHR( StructureChainAllocator & structureChainAllocator, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyProperties2KHR && |
| "Function <vkGetPhysicalDeviceQueueFamilyProperties2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| std::vector<StructureChain, StructureChainAllocator> structureChains( structureChainAllocator ); |
| std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> queueFamilyProperties; |
| uint32_t queueFamilyPropertyCount; |
| d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, nullptr ); |
| structureChains.resize( queueFamilyPropertyCount ); |
| queueFamilyProperties.resize( queueFamilyPropertyCount ); |
| for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ ) |
| { |
| queueFamilyProperties[i].pNext = structureChains[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>().pNext; |
| } |
| d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( |
| m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) ); |
| |
| VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() ); |
| if ( queueFamilyPropertyCount < queueFamilyProperties.size() ) |
| { |
| structureChains.resize( queueFamilyPropertyCount ); |
| } |
| for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ ) |
| { |
| structureChains[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>() = queueFamilyProperties[i]; |
| } |
| return structureChains; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void PhysicalDevice::getMemoryProperties2KHR( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 * pMemoryProperties, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetPhysicalDeviceMemoryProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>( pMemoryProperties ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 |
| PhysicalDevice::getMemoryProperties2KHR( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceMemoryProperties2KHR && |
| "Function <vkGetPhysicalDeviceMemoryProperties2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 memoryProperties; |
| d.vkGetPhysicalDeviceMemoryProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>( &memoryProperties ) ); |
| |
| return memoryProperties; |
| } |
| |
| template <typename X, typename Y, typename... Z, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> |
| PhysicalDevice::getMemoryProperties2KHR( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceMemoryProperties2KHR && |
| "Function <vkGetPhysicalDeviceMemoryProperties2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain; |
| VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 & memoryProperties = |
| structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2>(); |
| d.vkGetPhysicalDeviceMemoryProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>( &memoryProperties ) ); |
| |
| return structureChain; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void PhysicalDevice::getSparseImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 * pFormatInfo, |
| uint32_t * pPropertyCount, |
| VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 * pProperties, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR( m_physicalDevice, |
| reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( pFormatInfo ), |
| pPropertyCount, |
| reinterpret_cast<VkSparseImageFormatProperties2 *>( pProperties ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename SparseImageFormatProperties2Allocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2, SparseImageFormatProperties2Allocator> |
| PhysicalDevice::getSparseImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR && |
| "Function <vkGetPhysicalDeviceSparseImageFormatProperties2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2, SparseImageFormatProperties2Allocator> properties; |
| uint32_t propertyCount; |
| d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR( |
| m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ), &propertyCount, nullptr ); |
| properties.resize( propertyCount ); |
| d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR( m_physicalDevice, |
| reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ), |
| &propertyCount, |
| reinterpret_cast<VkSparseImageFormatProperties2 *>( properties.data() ) ); |
| |
| VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); |
| if ( propertyCount < properties.size() ) |
| { |
| properties.resize( propertyCount ); |
| } |
| return properties; |
| } |
| |
| template < |
| typename SparseImageFormatProperties2Allocator, |
| typename Dispatch, |
| typename std::enable_if<std::is_same<typename SparseImageFormatProperties2Allocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>::value, |
| int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2, SparseImageFormatProperties2Allocator> |
| PhysicalDevice::getSparseImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo, |
| SparseImageFormatProperties2Allocator & sparseImageFormatProperties2Allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR && |
| "Function <vkGetPhysicalDeviceSparseImageFormatProperties2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2, SparseImageFormatProperties2Allocator> properties( sparseImageFormatProperties2Allocator ); |
| uint32_t propertyCount; |
| d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR( |
| m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ), &propertyCount, nullptr ); |
| properties.resize( propertyCount ); |
| d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR( m_physicalDevice, |
| reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ), |
| &propertyCount, |
| reinterpret_cast<VkSparseImageFormatProperties2 *>( properties.data() ) ); |
| |
| VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); |
| if ( propertyCount < properties.size() ) |
| { |
| properties.resize( propertyCount ); |
| } |
| return properties; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_KHR_device_group === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, |
| uint32_t localDeviceIndex, |
| uint32_t remoteDeviceIndex, |
| VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags * pPeerMemoryFeatures, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetDeviceGroupPeerMemoryFeaturesKHR( |
| m_device, heapIndex, localDeviceIndex, remoteDeviceIndex, reinterpret_cast<VkPeerMemoryFeatureFlags *>( pPeerMemoryFeatures ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags Device::getGroupPeerMemoryFeaturesKHR( |
| uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetDeviceGroupPeerMemoryFeaturesKHR && |
| "Function <vkGetDeviceGroupPeerMemoryFeaturesKHR> requires <VK_KHR_device_group> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags peerMemoryFeatures; |
| d.vkGetDeviceGroupPeerMemoryFeaturesKHR( |
| m_device, heapIndex, localDeviceIndex, remoteDeviceIndex, reinterpret_cast<VkPeerMemoryFeatureFlags *>( &peerMemoryFeatures ) ); |
| |
| return peerMemoryFeatures; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setDeviceMaskKHR( uint32_t deviceMask, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetDeviceMaskKHR( m_commandBuffer, deviceMask ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::dispatchBaseKHR( uint32_t baseGroupX, |
| uint32_t baseGroupY, |
| uint32_t baseGroupZ, |
| uint32_t groupCountX, |
| uint32_t groupCountY, |
| uint32_t groupCountZ, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdDispatchBaseKHR( m_commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ ); |
| } |
| |
| #if defined( VK_USE_PLATFORM_VI_NN ) |
| //=== VK_NN_vi_surface === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createViSurfaceNN( const VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateViSurfaceNN( m_instance, |
| reinterpret_cast<const VkViSurfaceCreateInfoNN *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) ); |
| } |
| |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type |
| Instance::createViSurfaceNN( const VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateViSurfaceNN && "Function <vkCreateViSurfaceNN> requires <VK_NN_vi_surface>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateViSurfaceNN( m_instance, |
| reinterpret_cast<const VkViSurfaceCreateInfoNN *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkSurfaceKHR *>( &surface ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createViSurfaceNN" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( surface ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type |
| Instance::createViSurfaceNNUnique( const VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateViSurfaceNN && "Function <vkCreateViSurfaceNN> requires <VK_NN_vi_surface>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateViSurfaceNN( m_instance, |
| reinterpret_cast<const VkViSurfaceCreateInfoNN *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkSurfaceKHR *>( &surface ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createViSurfaceNNUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>( surface, ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| #endif /*VK_USE_PLATFORM_VI_NN*/ |
| |
| //=== VK_KHR_maintenance1 === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::trimCommandPoolKHR( VULKAN_HPP_NAMESPACE::CommandPool commandPool, |
| VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkTrimCommandPoolKHR( m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolTrimFlags>( flags ) ); |
| } |
| |
| //=== VK_KHR_device_group_creation === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| Instance::enumeratePhysicalDeviceGroupsKHR( uint32_t * pPhysicalDeviceGroupCount, |
| VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkEnumeratePhysicalDeviceGroupsKHR( |
| m_instance, pPhysicalDeviceGroupCount, reinterpret_cast<VkPhysicalDeviceGroupProperties *>( pPhysicalDeviceGroupProperties ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename PhysicalDeviceGroupPropertiesAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE |
| typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type |
| Instance::enumeratePhysicalDeviceGroupsKHR( Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkEnumeratePhysicalDeviceGroupsKHR && |
| "Function <vkEnumeratePhysicalDeviceGroupsKHR> requires <VK_KHR_device_group_creation> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator> physicalDeviceGroupProperties; |
| uint32_t physicalDeviceGroupCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkEnumeratePhysicalDeviceGroupsKHR( m_instance, &physicalDeviceGroupCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && physicalDeviceGroupCount ) |
| { |
| physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkEnumeratePhysicalDeviceGroupsKHR( |
| m_instance, &physicalDeviceGroupCount, reinterpret_cast<VkPhysicalDeviceGroupProperties *>( physicalDeviceGroupProperties.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::enumeratePhysicalDeviceGroupsKHR" ); |
| VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() ); |
| if ( physicalDeviceGroupCount < physicalDeviceGroupProperties.size() ) |
| { |
| physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( physicalDeviceGroupProperties ) ); |
| } |
| |
| template <typename PhysicalDeviceGroupPropertiesAllocator, |
| typename Dispatch, |
| typename std::enable_if< |
| std::is_same<typename PhysicalDeviceGroupPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>::value, |
| int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE |
| typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type |
| Instance::enumeratePhysicalDeviceGroupsKHR( PhysicalDeviceGroupPropertiesAllocator & physicalDeviceGroupPropertiesAllocator, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkEnumeratePhysicalDeviceGroupsKHR && |
| "Function <vkEnumeratePhysicalDeviceGroupsKHR> requires <VK_KHR_device_group_creation> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator> physicalDeviceGroupProperties( |
| physicalDeviceGroupPropertiesAllocator ); |
| uint32_t physicalDeviceGroupCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkEnumeratePhysicalDeviceGroupsKHR( m_instance, &physicalDeviceGroupCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && physicalDeviceGroupCount ) |
| { |
| physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkEnumeratePhysicalDeviceGroupsKHR( |
| m_instance, &physicalDeviceGroupCount, reinterpret_cast<VkPhysicalDeviceGroupProperties *>( physicalDeviceGroupProperties.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::enumeratePhysicalDeviceGroupsKHR" ); |
| VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() ); |
| if ( physicalDeviceGroupCount < physicalDeviceGroupProperties.size() ) |
| { |
| physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( physicalDeviceGroupProperties ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_KHR_external_memory_capabilities === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void PhysicalDevice::getExternalBufferPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo * pExternalBufferInfo, |
| VULKAN_HPP_NAMESPACE::ExternalBufferProperties * pExternalBufferProperties, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetPhysicalDeviceExternalBufferPropertiesKHR( m_physicalDevice, |
| reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo *>( pExternalBufferInfo ), |
| reinterpret_cast<VkExternalBufferProperties *>( pExternalBufferProperties ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalBufferProperties |
| PhysicalDevice::getExternalBufferPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo & externalBufferInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceExternalBufferPropertiesKHR && |
| "Function <vkGetPhysicalDeviceExternalBufferPropertiesKHR> requires <VK_KHR_external_memory_capabilities> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::ExternalBufferProperties externalBufferProperties; |
| d.vkGetPhysicalDeviceExternalBufferPropertiesKHR( m_physicalDevice, |
| reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo *>( &externalBufferInfo ), |
| reinterpret_cast<VkExternalBufferProperties *>( &externalBufferProperties ) ); |
| |
| return externalBufferProperties; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| #if defined( VK_USE_PLATFORM_WIN32_KHR ) |
| //=== VK_KHR_external_memory_win32 === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getMemoryWin32HandleKHR( const VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR * pGetWin32HandleInfo, |
| HANDLE * pHandle, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( |
| d.vkGetMemoryWin32HandleKHR( m_device, reinterpret_cast<const VkMemoryGetWin32HandleInfoKHR *>( pGetWin32HandleInfo ), pHandle ) ); |
| } |
| |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<HANDLE>::type |
| Device::getMemoryWin32HandleKHR( const VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetMemoryWin32HandleKHR && "Function <vkGetMemoryWin32HandleKHR> requires <VK_KHR_external_memory_win32>" ); |
| # endif |
| |
| HANDLE handle; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetMemoryWin32HandleKHR( m_device, reinterpret_cast<const VkMemoryGetWin32HandleInfoKHR *>( &getWin32HandleInfo ), &handle ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryWin32HandleKHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( handle ) ); |
| } |
| # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| Device::getMemoryWin32HandlePropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, |
| HANDLE handle, |
| VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR * pMemoryWin32HandleProperties, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetMemoryWin32HandlePropertiesKHR( m_device, |
| static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ), |
| handle, |
| reinterpret_cast<VkMemoryWin32HandlePropertiesKHR *>( pMemoryWin32HandleProperties ) ) ); |
| } |
| |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR>::type |
| Device::getMemoryWin32HandlePropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetMemoryWin32HandlePropertiesKHR && "Function <vkGetMemoryWin32HandlePropertiesKHR> requires <VK_KHR_external_memory_win32>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR memoryWin32HandleProperties; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetMemoryWin32HandlePropertiesKHR( m_device, |
| static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ), |
| handle, |
| reinterpret_cast<VkMemoryWin32HandlePropertiesKHR *>( &memoryWin32HandleProperties ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryWin32HandlePropertiesKHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( memoryWin32HandleProperties ) ); |
| } |
| # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| #endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| //=== VK_KHR_external_memory_fd === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getMemoryFdKHR( const VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR * pGetFdInfo, |
| int * pFd, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetMemoryFdKHR( m_device, reinterpret_cast<const VkMemoryGetFdInfoKHR *>( pGetFdInfo ), pFd ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<int>::type Device::getMemoryFdKHR( const VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR & getFdInfo, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetMemoryFdKHR && "Function <vkGetMemoryFdKHR> requires <VK_KHR_external_memory_fd>" ); |
| # endif |
| |
| int fd; |
| VULKAN_HPP_NAMESPACE::Result result = |
| static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetMemoryFdKHR( m_device, reinterpret_cast<const VkMemoryGetFdInfoKHR *>( &getFdInfo ), &fd ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryFdKHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( fd ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getMemoryFdPropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, |
| int fd, |
| VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR * pMemoryFdProperties, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetMemoryFdPropertiesKHR( |
| m_device, static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ), fd, reinterpret_cast<VkMemoryFdPropertiesKHR *>( pMemoryFdProperties ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR>::type |
| Device::getMemoryFdPropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, int fd, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetMemoryFdPropertiesKHR && "Function <vkGetMemoryFdPropertiesKHR> requires <VK_KHR_external_memory_fd>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR memoryFdProperties; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetMemoryFdPropertiesKHR( |
| m_device, static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ), fd, reinterpret_cast<VkMemoryFdPropertiesKHR *>( &memoryFdProperties ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryFdPropertiesKHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( memoryFdProperties ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_KHR_external_semaphore_capabilities === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void |
| PhysicalDevice::getExternalSemaphorePropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo, |
| VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties * pExternalSemaphoreProperties, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( m_physicalDevice, |
| reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo *>( pExternalSemaphoreInfo ), |
| reinterpret_cast<VkExternalSemaphoreProperties *>( pExternalSemaphoreProperties ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties |
| PhysicalDevice::getExternalSemaphorePropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR && |
| "Function <vkGetPhysicalDeviceExternalSemaphorePropertiesKHR> requires <VK_KHR_external_semaphore_capabilities> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties externalSemaphoreProperties; |
| d.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( m_physicalDevice, |
| reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo *>( &externalSemaphoreInfo ), |
| reinterpret_cast<VkExternalSemaphoreProperties *>( &externalSemaphoreProperties ) ); |
| |
| return externalSemaphoreProperties; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| #if defined( VK_USE_PLATFORM_WIN32_KHR ) |
| //=== VK_KHR_external_semaphore_win32 === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::importSemaphoreWin32HandleKHR( |
| const VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR * pImportSemaphoreWin32HandleInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( |
| d.vkImportSemaphoreWin32HandleKHR( m_device, reinterpret_cast<const VkImportSemaphoreWin32HandleInfoKHR *>( pImportSemaphoreWin32HandleInfo ) ) ); |
| } |
| |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type |
| Device::importSemaphoreWin32HandleKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkImportSemaphoreWin32HandleKHR && "Function <vkImportSemaphoreWin32HandleKHR> requires <VK_KHR_external_semaphore_win32>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkImportSemaphoreWin32HandleKHR( m_device, reinterpret_cast<const VkImportSemaphoreWin32HandleInfoKHR *>( &importSemaphoreWin32HandleInfo ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::importSemaphoreWin32HandleKHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); |
| } |
| # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSemaphoreWin32HandleKHR( |
| const VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR * pGetWin32HandleInfo, HANDLE * pHandle, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( |
| d.vkGetSemaphoreWin32HandleKHR( m_device, reinterpret_cast<const VkSemaphoreGetWin32HandleInfoKHR *>( pGetWin32HandleInfo ), pHandle ) ); |
| } |
| |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<HANDLE>::type |
| Device::getSemaphoreWin32HandleKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetSemaphoreWin32HandleKHR && "Function <vkGetSemaphoreWin32HandleKHR> requires <VK_KHR_external_semaphore_win32>" ); |
| # endif |
| |
| HANDLE handle; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetSemaphoreWin32HandleKHR( m_device, reinterpret_cast<const VkSemaphoreGetWin32HandleInfoKHR *>( &getWin32HandleInfo ), &handle ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreWin32HandleKHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( handle ) ); |
| } |
| # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| #endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| //=== VK_KHR_external_semaphore_fd === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::importSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR * pImportSemaphoreFdInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkImportSemaphoreFdKHR( m_device, reinterpret_cast<const VkImportSemaphoreFdInfoKHR *>( pImportSemaphoreFdInfo ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type |
| Device::importSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR & importSemaphoreFdInfo, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkImportSemaphoreFdKHR && "Function <vkImportSemaphoreFdKHR> requires <VK_KHR_external_semaphore_fd>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkImportSemaphoreFdKHR( m_device, reinterpret_cast<const VkImportSemaphoreFdInfoKHR *>( &importSemaphoreFdInfo ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::importSemaphoreFdKHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR * pGetFdInfo, |
| int * pFd, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetSemaphoreFdKHR( m_device, reinterpret_cast<const VkSemaphoreGetFdInfoKHR *>( pGetFdInfo ), pFd ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<int>::type |
| Device::getSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR & getFdInfo, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetSemaphoreFdKHR && "Function <vkGetSemaphoreFdKHR> requires <VK_KHR_external_semaphore_fd>" ); |
| # endif |
| |
| int fd; |
| VULKAN_HPP_NAMESPACE::Result result = |
| static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetSemaphoreFdKHR( m_device, reinterpret_cast<const VkSemaphoreGetFdInfoKHR *>( &getFdInfo ), &fd ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreFdKHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( fd ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_KHR_push_descriptor === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetKHR( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, |
| VULKAN_HPP_NAMESPACE::PipelineLayout layout, |
| uint32_t set, |
| uint32_t descriptorWriteCount, |
| const VULKAN_HPP_NAMESPACE::WriteDescriptorSet * pDescriptorWrites, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdPushDescriptorSetKHR( m_commandBuffer, |
| static_cast<VkPipelineBindPoint>( pipelineBindPoint ), |
| static_cast<VkPipelineLayout>( layout ), |
| set, |
| descriptorWriteCount, |
| reinterpret_cast<const VkWriteDescriptorSet *>( pDescriptorWrites ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void |
| CommandBuffer::pushDescriptorSetKHR( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, |
| VULKAN_HPP_NAMESPACE::PipelineLayout layout, |
| uint32_t set, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdPushDescriptorSetKHR && "Function <vkCmdPushDescriptorSetKHR> requires <VK_KHR_push_descriptor>" ); |
| # endif |
| |
| d.vkCmdPushDescriptorSetKHR( m_commandBuffer, |
| static_cast<VkPipelineBindPoint>( pipelineBindPoint ), |
| static_cast<VkPipelineLayout>( layout ), |
| set, |
| descriptorWrites.size(), |
| reinterpret_cast<const VkWriteDescriptorSet *>( descriptorWrites.data() ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, |
| VULKAN_HPP_NAMESPACE::PipelineLayout layout, |
| uint32_t set, |
| const void * pData, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdPushDescriptorSetWithTemplateKHR( |
| m_commandBuffer, static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), static_cast<VkPipelineLayout>( layout ), set, pData ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename DataType, typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, |
| VULKAN_HPP_NAMESPACE::PipelineLayout layout, |
| uint32_t set, |
| DataType const & data, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdPushDescriptorSetWithTemplateKHR && |
| "Function <vkCmdPushDescriptorSetWithTemplateKHR> requires <VK_KHR_descriptor_update_template> or <VK_KHR_push_descriptor>" ); |
| # endif |
| |
| d.vkCmdPushDescriptorSetWithTemplateKHR( m_commandBuffer, |
| static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), |
| static_cast<VkPipelineLayout>( layout ), |
| set, |
| reinterpret_cast<const void *>( &data ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_EXT_conditional_rendering === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::beginConditionalRenderingEXT( const VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT * pConditionalRenderingBegin, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdBeginConditionalRenderingEXT( m_commandBuffer, reinterpret_cast<const VkConditionalRenderingBeginInfoEXT *>( pConditionalRenderingBegin ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::beginConditionalRenderingEXT( const VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT & conditionalRenderingBegin, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdBeginConditionalRenderingEXT && "Function <vkCmdBeginConditionalRenderingEXT> requires <VK_EXT_conditional_rendering>" ); |
| # endif |
| |
| d.vkCmdBeginConditionalRenderingEXT( m_commandBuffer, reinterpret_cast<const VkConditionalRenderingBeginInfoEXT *>( &conditionalRenderingBegin ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::endConditionalRenderingEXT( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdEndConditionalRenderingEXT( m_commandBuffer ); |
| } |
| |
| //=== VK_KHR_descriptor_update_template === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| Device::createDescriptorUpdateTemplateKHR( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate * pDescriptorUpdateTemplate, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateDescriptorUpdateTemplateKHR( m_device, |
| reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkDescriptorUpdateTemplate *>( pDescriptorUpdateTemplate ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate>::type |
| Device::createDescriptorUpdateTemplateKHR( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateDescriptorUpdateTemplateKHR && |
| "Function <vkCreateDescriptorUpdateTemplateKHR> requires <VK_KHR_descriptor_update_template> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateDescriptorUpdateTemplateKHR( |
| m_device, |
| reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkDescriptorUpdateTemplate *>( &descriptorUpdateTemplate ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorUpdateTemplateKHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( descriptorUpdateTemplate ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate, Dispatch>>::type |
| Device::createDescriptorUpdateTemplateKHRUnique( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateDescriptorUpdateTemplateKHR && |
| "Function <vkCreateDescriptorUpdateTemplateKHR> requires <VK_KHR_descriptor_update_template> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateDescriptorUpdateTemplateKHR( |
| m_device, |
| reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkDescriptorUpdateTemplate *>( &descriptorUpdateTemplate ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorUpdateTemplateKHRUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, |
| UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate, Dispatch>( |
| descriptorUpdateTemplate, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyDescriptorUpdateTemplateKHR( |
| m_device, static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyDescriptorUpdateTemplateKHR && |
| "Function <vkDestroyDescriptorUpdateTemplateKHR> requires <VK_KHR_descriptor_update_template> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| d.vkDestroyDescriptorUpdateTemplateKHR( |
| m_device, |
| static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::updateDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet, |
| VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, |
| const void * pData, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkUpdateDescriptorSetWithTemplateKHR( |
| m_device, static_cast<VkDescriptorSet>( descriptorSet ), static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), pData ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename DataType, typename Dispatch> |
| VULKAN_HPP_INLINE void Device::updateDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet, |
| VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, |
| DataType const & data, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkUpdateDescriptorSetWithTemplateKHR && |
| "Function <vkUpdateDescriptorSetWithTemplateKHR> requires <VK_KHR_descriptor_update_template> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| d.vkUpdateDescriptorSetWithTemplateKHR( m_device, |
| static_cast<VkDescriptorSet>( descriptorSet ), |
| static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), |
| reinterpret_cast<const void *>( &data ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_NV_clip_space_w_scaling === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setViewportWScalingNV( uint32_t firstViewport, |
| uint32_t viewportCount, |
| const VULKAN_HPP_NAMESPACE::ViewportWScalingNV * pViewportWScalings, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetViewportWScalingNV( m_commandBuffer, firstViewport, viewportCount, reinterpret_cast<const VkViewportWScalingNV *>( pViewportWScalings ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void |
| CommandBuffer::setViewportWScalingNV( uint32_t firstViewport, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ViewportWScalingNV> const & viewportWScalings, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdSetViewportWScalingNV && "Function <vkCmdSetViewportWScalingNV> requires <VK_NV_clip_space_w_scaling>" ); |
| # endif |
| |
| d.vkCmdSetViewportWScalingNV( |
| m_commandBuffer, firstViewport, viewportWScalings.size(), reinterpret_cast<const VkViewportWScalingNV *>( viewportWScalings.data() ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_EXT_direct_mode_display === |
| |
| #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 |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkReleaseDisplayEXT( m_physicalDevice, static_cast<VkDisplayKHR>( display ) ) ); |
| } |
| #else |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void PhysicalDevice::releaseDisplayEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkReleaseDisplayEXT && "Function <vkReleaseDisplayEXT> requires <VK_EXT_direct_mode_display>" ); |
| # endif |
| |
| d.vkReleaseDisplayEXT( m_physicalDevice, static_cast<VkDisplayKHR>( display ) ); |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| #if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT ) |
| //=== VK_EXT_acquire_xlib_display === |
| |
| 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 |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkAcquireXlibDisplayEXT( m_physicalDevice, dpy, static_cast<VkDisplayKHR>( display ) ) ); |
| } |
| |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type |
| PhysicalDevice::acquireXlibDisplayEXT( Display & dpy, VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkAcquireXlibDisplayEXT && "Function <vkAcquireXlibDisplayEXT> requires <VK_EXT_acquire_xlib_display>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = |
| static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkAcquireXlibDisplayEXT( m_physicalDevice, &dpy, static_cast<VkDisplayKHR>( display ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::acquireXlibDisplayEXT" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); |
| } |
| # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getRandROutputDisplayEXT( Display * dpy, |
| RROutput rrOutput, |
| VULKAN_HPP_NAMESPACE::DisplayKHR * pDisplay, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetRandROutputDisplayEXT( m_physicalDevice, dpy, rrOutput, reinterpret_cast<VkDisplayKHR *>( pDisplay ) ) ); |
| } |
| |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayKHR>::type |
| PhysicalDevice::getRandROutputDisplayEXT( Display & dpy, RROutput rrOutput, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetRandROutputDisplayEXT && "Function <vkGetRandROutputDisplayEXT> requires <VK_EXT_acquire_xlib_display>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::DisplayKHR display; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetRandROutputDisplayEXT( m_physicalDevice, &dpy, rrOutput, reinterpret_cast<VkDisplayKHR *>( &display ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getRandROutputDisplayEXT" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( display ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>>::type |
| PhysicalDevice::getRandROutputDisplayEXTUnique( Display & dpy, RROutput rrOutput, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetRandROutputDisplayEXT && "Function <vkGetRandROutputDisplayEXT> requires <VK_EXT_acquire_xlib_display>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::DisplayKHR display; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetRandROutputDisplayEXT( m_physicalDevice, &dpy, rrOutput, reinterpret_cast<VkDisplayKHR *>( &display ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getRandROutputDisplayEXTUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>( display, ObjectRelease<PhysicalDevice, Dispatch>( *this, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| #endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ |
| |
| //=== VK_EXT_display_surface_counter === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| PhysicalDevice::getSurfaceCapabilities2EXT( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, |
| VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT * pSurfaceCapabilities, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilities2EXT( |
| m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkSurfaceCapabilities2EXT *>( pSurfaceCapabilities ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT>::type |
| PhysicalDevice::getSurfaceCapabilities2EXT( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfaceCapabilities2EXT && |
| "Function <vkGetPhysicalDeviceSurfaceCapabilities2EXT> requires <VK_EXT_display_surface_counter>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT surfaceCapabilities; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPhysicalDeviceSurfaceCapabilities2EXT( |
| m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkSurfaceCapabilities2EXT *>( &surfaceCapabilities ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilities2EXT" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( surfaceCapabilities ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_EXT_display_control === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::displayPowerControlEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, |
| const VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT * pDisplayPowerInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( |
| d.vkDisplayPowerControlEXT( m_device, static_cast<VkDisplayKHR>( display ), reinterpret_cast<const VkDisplayPowerInfoEXT *>( pDisplayPowerInfo ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::displayPowerControlEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, |
| const VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT & displayPowerInfo, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDisplayPowerControlEXT && "Function <vkDisplayPowerControlEXT> requires <VK_EXT_display_control>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkDisplayPowerControlEXT( m_device, static_cast<VkDisplayKHR>( display ), reinterpret_cast<const VkDisplayPowerInfoEXT *>( &displayPowerInfo ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::displayPowerControlEXT" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::registerEventEXT( const VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT * pDeviceEventInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::Fence * pFence, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkRegisterDeviceEventEXT( m_device, |
| reinterpret_cast<const VkDeviceEventInfoEXT *>( pDeviceEventInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkFence *>( pFence ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::Fence>::type |
| Device::registerEventEXT( const VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT & deviceEventInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkRegisterDeviceEventEXT && "Function <vkRegisterDeviceEventEXT> requires <VK_EXT_display_control>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Fence fence; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkRegisterDeviceEventEXT( |
| m_device, |
| reinterpret_cast<const VkDeviceEventInfoEXT *>( &deviceEventInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkFence *>( &fence ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::registerEventEXT" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( fence ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>>::type |
| Device::registerEventEXTUnique( const VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT & deviceEventInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkRegisterDeviceEventEXT && "Function <vkRegisterDeviceEventEXT> requires <VK_EXT_display_control>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Fence fence; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkRegisterDeviceEventEXT( |
| m_device, |
| reinterpret_cast<const VkDeviceEventInfoEXT *>( &deviceEventInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkFence *>( &fence ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::registerEventEXTUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>( fence, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::registerDisplayEventEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, |
| const VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT * pDisplayEventInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::Fence * pFence, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkRegisterDisplayEventEXT( m_device, |
| static_cast<VkDisplayKHR>( display ), |
| reinterpret_cast<const VkDisplayEventInfoEXT *>( pDisplayEventInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkFence *>( pFence ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::Fence>::type |
| Device::registerDisplayEventEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, |
| const VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT & displayEventInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkRegisterDisplayEventEXT && "Function <vkRegisterDisplayEventEXT> requires <VK_EXT_display_control>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Fence fence; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkRegisterDisplayEventEXT( |
| m_device, |
| static_cast<VkDisplayKHR>( display ), |
| reinterpret_cast<const VkDisplayEventInfoEXT *>( &displayEventInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkFence *>( &fence ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::registerDisplayEventEXT" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( fence ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>>::type |
| Device::registerDisplayEventEXTUnique( VULKAN_HPP_NAMESPACE::DisplayKHR display, |
| const VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT & displayEventInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkRegisterDisplayEventEXT && "Function <vkRegisterDisplayEventEXT> requires <VK_EXT_display_control>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Fence fence; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkRegisterDisplayEventEXT( |
| m_device, |
| static_cast<VkDisplayKHR>( display ), |
| reinterpret_cast<const VkDisplayEventInfoEXT *>( &displayEventInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkFence *>( &fence ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::registerDisplayEventEXTUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>( fence, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSwapchainCounterEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, |
| VULKAN_HPP_NAMESPACE::SurfaceCounterFlagBitsEXT counter, |
| uint64_t * pCounterValue, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( |
| d.vkGetSwapchainCounterEXT( m_device, static_cast<VkSwapchainKHR>( swapchain ), static_cast<VkSurfaceCounterFlagBitsEXT>( counter ), pCounterValue ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<uint64_t>::type Device::getSwapchainCounterEXT( |
| VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, VULKAN_HPP_NAMESPACE::SurfaceCounterFlagBitsEXT counter, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetSwapchainCounterEXT && "Function <vkGetSwapchainCounterEXT> requires <VK_EXT_display_control>" ); |
| # endif |
| |
| uint64_t counterValue; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetSwapchainCounterEXT( m_device, static_cast<VkSwapchainKHR>( swapchain ), static_cast<VkSurfaceCounterFlagBitsEXT>( counter ), &counterValue ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSwapchainCounterEXT" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( counterValue ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_GOOGLE_display_timing === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| Device::getRefreshCycleDurationGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, |
| VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE * pDisplayTimingProperties, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetRefreshCycleDurationGOOGLE( |
| m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<VkRefreshCycleDurationGOOGLE *>( pDisplayTimingProperties ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE>::type |
| Device::getRefreshCycleDurationGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetRefreshCycleDurationGOOGLE && "Function <vkGetRefreshCycleDurationGOOGLE> requires <VK_GOOGLE_display_timing>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE displayTimingProperties; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetRefreshCycleDurationGOOGLE( |
| m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<VkRefreshCycleDurationGOOGLE *>( &displayTimingProperties ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getRefreshCycleDurationGOOGLE" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( displayTimingProperties ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| Device::getPastPresentationTimingGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, |
| uint32_t * pPresentationTimingCount, |
| VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE * pPresentationTimings, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetPastPresentationTimingGOOGLE( m_device, |
| static_cast<VkSwapchainKHR>( swapchain ), |
| pPresentationTimingCount, |
| reinterpret_cast<VkPastPresentationTimingGOOGLE *>( pPresentationTimings ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename PastPresentationTimingGOOGLEAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE |
| typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator>>::type |
| Device::getPastPresentationTimingGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPastPresentationTimingGOOGLE && "Function <vkGetPastPresentationTimingGOOGLE> requires <VK_GOOGLE_display_timing>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator> presentationTimings; |
| uint32_t presentationTimingCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetPastPresentationTimingGOOGLE( m_device, static_cast<VkSwapchainKHR>( swapchain ), &presentationTimingCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && presentationTimingCount ) |
| { |
| presentationTimings.resize( presentationTimingCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetPastPresentationTimingGOOGLE( m_device, |
| static_cast<VkSwapchainKHR>( swapchain ), |
| &presentationTimingCount, |
| reinterpret_cast<VkPastPresentationTimingGOOGLE *>( presentationTimings.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPastPresentationTimingGOOGLE" ); |
| VULKAN_HPP_ASSERT( presentationTimingCount <= presentationTimings.size() ); |
| if ( presentationTimingCount < presentationTimings.size() ) |
| { |
| presentationTimings.resize( presentationTimingCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( presentationTimings ) ); |
| } |
| |
| template < |
| typename PastPresentationTimingGOOGLEAllocator, |
| typename Dispatch, |
| typename std::enable_if<std::is_same<typename PastPresentationTimingGOOGLEAllocator::value_type, VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE>::value, |
| int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE |
| typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator>>::type |
| Device::getPastPresentationTimingGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, |
| PastPresentationTimingGOOGLEAllocator & pastPresentationTimingGOOGLEAllocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPastPresentationTimingGOOGLE && "Function <vkGetPastPresentationTimingGOOGLE> requires <VK_GOOGLE_display_timing>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator> presentationTimings( |
| pastPresentationTimingGOOGLEAllocator ); |
| uint32_t presentationTimingCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetPastPresentationTimingGOOGLE( m_device, static_cast<VkSwapchainKHR>( swapchain ), &presentationTimingCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && presentationTimingCount ) |
| { |
| presentationTimings.resize( presentationTimingCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetPastPresentationTimingGOOGLE( m_device, |
| static_cast<VkSwapchainKHR>( swapchain ), |
| &presentationTimingCount, |
| reinterpret_cast<VkPastPresentationTimingGOOGLE *>( presentationTimings.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPastPresentationTimingGOOGLE" ); |
| VULKAN_HPP_ASSERT( presentationTimingCount <= presentationTimings.size() ); |
| if ( presentationTimingCount < presentationTimings.size() ) |
| { |
| presentationTimings.resize( presentationTimingCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( presentationTimings ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_EXT_discard_rectangles === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setDiscardRectangleEXT( uint32_t firstDiscardRectangle, |
| uint32_t discardRectangleCount, |
| const VULKAN_HPP_NAMESPACE::Rect2D * pDiscardRectangles, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetDiscardRectangleEXT( m_commandBuffer, firstDiscardRectangle, discardRectangleCount, reinterpret_cast<const VkRect2D *>( pDiscardRectangles ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setDiscardRectangleEXT( uint32_t firstDiscardRectangle, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & discardRectangles, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdSetDiscardRectangleEXT && "Function <vkCmdSetDiscardRectangleEXT> requires <VK_EXT_discard_rectangles>" ); |
| # endif |
| |
| d.vkCmdSetDiscardRectangleEXT( |
| m_commandBuffer, firstDiscardRectangle, discardRectangles.size(), reinterpret_cast<const VkRect2D *>( discardRectangles.data() ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setDiscardRectangleEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 discardRectangleEnable, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetDiscardRectangleEnableEXT( m_commandBuffer, static_cast<VkBool32>( discardRectangleEnable ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setDiscardRectangleModeEXT( VULKAN_HPP_NAMESPACE::DiscardRectangleModeEXT discardRectangleMode, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetDiscardRectangleModeEXT( m_commandBuffer, static_cast<VkDiscardRectangleModeEXT>( discardRectangleMode ) ); |
| } |
| |
| //=== VK_EXT_hdr_metadata === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::setHdrMetadataEXT( uint32_t swapchainCount, |
| const VULKAN_HPP_NAMESPACE::SwapchainKHR * pSwapchains, |
| const VULKAN_HPP_NAMESPACE::HdrMetadataEXT * pMetadata, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkSetHdrMetadataEXT( |
| m_device, swapchainCount, reinterpret_cast<const VkSwapchainKHR *>( pSwapchains ), reinterpret_cast<const VkHdrMetadataEXT *>( pMetadata ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::setHdrMetadataEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainKHR> const & swapchains, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::HdrMetadataEXT> const & metadata, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkSetHdrMetadataEXT && "Function <vkSetHdrMetadataEXT> requires <VK_EXT_hdr_metadata>" ); |
| # endif |
| # ifdef VULKAN_HPP_NO_EXCEPTIONS |
| VULKAN_HPP_ASSERT( swapchains.size() == metadata.size() ); |
| # else |
| if ( swapchains.size() != metadata.size() ) |
| { |
| throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::Device::setHdrMetadataEXT: swapchains.size() != metadata.size()" ); |
| } |
| # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ |
| |
| d.vkSetHdrMetadataEXT( m_device, |
| swapchains.size(), |
| reinterpret_cast<const VkSwapchainKHR *>( swapchains.data() ), |
| reinterpret_cast<const VkHdrMetadataEXT *>( metadata.data() ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_KHR_create_renderpass2 === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::RenderPass * pRenderPass, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateRenderPass2KHR( m_device, |
| reinterpret_cast<const VkRenderPassCreateInfo2 *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkRenderPass *>( pRenderPass ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::RenderPass>::type |
| Device::createRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateRenderPass2KHR && "Function <vkCreateRenderPass2KHR> requires <VK_KHR_create_renderpass2> or <VK_VERSION_1_2>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::RenderPass renderPass; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateRenderPass2KHR( m_device, |
| reinterpret_cast<const VkRenderPassCreateInfo2 *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkRenderPass *>( &renderPass ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPass2KHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( renderPass ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>>::type |
| Device::createRenderPass2KHRUnique( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateRenderPass2KHR && "Function <vkCreateRenderPass2KHR> requires <VK_KHR_create_renderpass2> or <VK_VERSION_1_2>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::RenderPass renderPass; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateRenderPass2KHR( m_device, |
| reinterpret_cast<const VkRenderPassCreateInfo2 *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkRenderPass *>( &renderPass ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPass2KHRUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>( renderPass, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo * pRenderPassBegin, |
| const VULKAN_HPP_NAMESPACE::SubpassBeginInfo * pSubpassBeginInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdBeginRenderPass2KHR( |
| m_commandBuffer, reinterpret_cast<const VkRenderPassBeginInfo *>( pRenderPassBegin ), reinterpret_cast<const VkSubpassBeginInfo *>( pSubpassBeginInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin, |
| const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdBeginRenderPass2KHR && "Function <vkCmdBeginRenderPass2KHR> requires <VK_KHR_create_renderpass2> or <VK_VERSION_1_2>" ); |
| # endif |
| |
| d.vkCmdBeginRenderPass2KHR( |
| m_commandBuffer, reinterpret_cast<const VkRenderPassBeginInfo *>( &renderPassBegin ), reinterpret_cast<const VkSubpassBeginInfo *>( &subpassBeginInfo ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::nextSubpass2KHR( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo * pSubpassBeginInfo, |
| const VULKAN_HPP_NAMESPACE::SubpassEndInfo * pSubpassEndInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdNextSubpass2KHR( |
| m_commandBuffer, reinterpret_cast<const VkSubpassBeginInfo *>( pSubpassBeginInfo ), reinterpret_cast<const VkSubpassEndInfo *>( pSubpassEndInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::nextSubpass2KHR( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo, |
| const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdNextSubpass2KHR && "Function <vkCmdNextSubpass2KHR> requires <VK_KHR_create_renderpass2> or <VK_VERSION_1_2>" ); |
| # endif |
| |
| d.vkCmdNextSubpass2KHR( |
| m_commandBuffer, reinterpret_cast<const VkSubpassBeginInfo *>( &subpassBeginInfo ), reinterpret_cast<const VkSubpassEndInfo *>( &subpassEndInfo ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::endRenderPass2KHR( const VULKAN_HPP_NAMESPACE::SubpassEndInfo * pSubpassEndInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdEndRenderPass2KHR( m_commandBuffer, reinterpret_cast<const VkSubpassEndInfo *>( pSubpassEndInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::endRenderPass2KHR( const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdEndRenderPass2KHR && "Function <vkCmdEndRenderPass2KHR> requires <VK_KHR_create_renderpass2> or <VK_VERSION_1_2>" ); |
| # endif |
| |
| d.vkCmdEndRenderPass2KHR( m_commandBuffer, reinterpret_cast<const VkSubpassEndInfo *>( &subpassEndInfo ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_KHR_shared_presentable_image === |
| |
| #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSwapchainStatusKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetSwapchainStatusKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ) ) ); |
| } |
| #else |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result Device::getSwapchainStatusKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetSwapchainStatusKHR && "Function <vkGetSwapchainStatusKHR> requires <VK_KHR_shared_presentable_image>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = |
| static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetSwapchainStatusKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, |
| VULKAN_HPP_NAMESPACE_STRING "::Device::getSwapchainStatusKHR", |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR } ); |
| |
| return static_cast<VULKAN_HPP_NAMESPACE::Result>( result ); |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| //=== VK_KHR_external_fence_capabilities === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void PhysicalDevice::getExternalFencePropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo * pExternalFenceInfo, |
| VULKAN_HPP_NAMESPACE::ExternalFenceProperties * pExternalFenceProperties, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetPhysicalDeviceExternalFencePropertiesKHR( m_physicalDevice, |
| reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo *>( pExternalFenceInfo ), |
| reinterpret_cast<VkExternalFenceProperties *>( pExternalFenceProperties ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalFenceProperties |
| PhysicalDevice::getExternalFencePropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo & externalFenceInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceExternalFencePropertiesKHR && |
| "Function <vkGetPhysicalDeviceExternalFencePropertiesKHR> requires <VK_KHR_external_fence_capabilities> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::ExternalFenceProperties externalFenceProperties; |
| d.vkGetPhysicalDeviceExternalFencePropertiesKHR( m_physicalDevice, |
| reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo *>( &externalFenceInfo ), |
| reinterpret_cast<VkExternalFenceProperties *>( &externalFenceProperties ) ); |
| |
| return externalFenceProperties; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| #if defined( VK_USE_PLATFORM_WIN32_KHR ) |
| //=== VK_KHR_external_fence_win32 === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::importFenceWin32HandleKHR( |
| const VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR * pImportFenceWin32HandleInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( |
| d.vkImportFenceWin32HandleKHR( m_device, reinterpret_cast<const VkImportFenceWin32HandleInfoKHR *>( pImportFenceWin32HandleInfo ) ) ); |
| } |
| |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type |
| Device::importFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkImportFenceWin32HandleKHR && "Function <vkImportFenceWin32HandleKHR> requires <VK_KHR_external_fence_win32>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkImportFenceWin32HandleKHR( m_device, reinterpret_cast<const VkImportFenceWin32HandleInfoKHR *>( &importFenceWin32HandleInfo ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::importFenceWin32HandleKHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); |
| } |
| # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR * pGetWin32HandleInfo, |
| HANDLE * pHandle, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( |
| d.vkGetFenceWin32HandleKHR( m_device, reinterpret_cast<const VkFenceGetWin32HandleInfoKHR *>( pGetWin32HandleInfo ), pHandle ) ); |
| } |
| |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<HANDLE>::type |
| Device::getFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetFenceWin32HandleKHR && "Function <vkGetFenceWin32HandleKHR> requires <VK_KHR_external_fence_win32>" ); |
| # endif |
| |
| HANDLE handle; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetFenceWin32HandleKHR( m_device, reinterpret_cast<const VkFenceGetWin32HandleInfoKHR *>( &getWin32HandleInfo ), &handle ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getFenceWin32HandleKHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( handle ) ); |
| } |
| # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| #endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| //=== VK_KHR_external_fence_fd === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::importFenceFdKHR( const VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR * pImportFenceFdInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkImportFenceFdKHR( m_device, reinterpret_cast<const VkImportFenceFdInfoKHR *>( pImportFenceFdInfo ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type |
| Device::importFenceFdKHR( const VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR & importFenceFdInfo, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkImportFenceFdKHR && "Function <vkImportFenceFdKHR> requires <VK_KHR_external_fence_fd>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = |
| static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkImportFenceFdKHR( m_device, reinterpret_cast<const VkImportFenceFdInfoKHR *>( &importFenceFdInfo ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::importFenceFdKHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getFenceFdKHR( const VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR * pGetFdInfo, |
| int * pFd, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetFenceFdKHR( m_device, reinterpret_cast<const VkFenceGetFdInfoKHR *>( pGetFdInfo ), pFd ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<int>::type Device::getFenceFdKHR( const VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR & getFdInfo, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetFenceFdKHR && "Function <vkGetFenceFdKHR> requires <VK_KHR_external_fence_fd>" ); |
| # endif |
| |
| int fd; |
| VULKAN_HPP_NAMESPACE::Result result = |
| static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetFenceFdKHR( m_device, reinterpret_cast<const VkFenceGetFdInfoKHR *>( &getFdInfo ), &fd ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getFenceFdKHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( fd ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_KHR_performance_query === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex, |
| uint32_t * pCounterCount, |
| VULKAN_HPP_NAMESPACE::PerformanceCounterKHR * pCounters, |
| VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR * pCounterDescriptions, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( |
| d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( m_physicalDevice, |
| queueFamilyIndex, |
| pCounterCount, |
| reinterpret_cast<VkPerformanceCounterKHR *>( pCounters ), |
| reinterpret_cast<VkPerformanceCounterDescriptionKHR *>( pCounterDescriptions ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename PerformanceCounterKHRAllocator, typename PerformanceCounterDescriptionKHRAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE |
| typename ResultValueType<std::pair<std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR, PerformanceCounterKHRAllocator>, |
| std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator>>>::type |
| PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR && |
| "Function <vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR> requires <VK_KHR_performance_query>" ); |
| # endif |
| |
| std::pair<std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR, PerformanceCounterKHRAllocator>, |
| std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator>> |
| data_; |
| std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR, PerformanceCounterKHRAllocator> & counters = data_.first; |
| std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator> & counterDescriptions = data_.second; |
| uint32_t counterCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( m_physicalDevice, queueFamilyIndex, &counterCount, nullptr, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && counterCount ) |
| { |
| counters.resize( counterCount ); |
| counterDescriptions.resize( counterCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( |
| m_physicalDevice, |
| queueFamilyIndex, |
| &counterCount, |
| reinterpret_cast<VkPerformanceCounterKHR *>( counters.data() ), |
| reinterpret_cast<VkPerformanceCounterDescriptionKHR *>( counterDescriptions.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR" ); |
| VULKAN_HPP_ASSERT( counterCount <= counters.size() ); |
| if ( counterCount < counters.size() ) |
| { |
| counters.resize( counterCount ); |
| counterDescriptions.resize( counterCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data_ ) ); |
| } |
| |
| template <typename PerformanceCounterKHRAllocator, |
| typename PerformanceCounterDescriptionKHRAllocator, |
| typename Dispatch, |
| typename std::enable_if< |
| std::is_same<typename PerformanceCounterKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::PerformanceCounterKHR>::value && |
| std::is_same<typename PerformanceCounterDescriptionKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR>::value, |
| int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE |
| typename ResultValueType<std::pair<std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR, PerformanceCounterKHRAllocator>, |
| std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator>>>::type |
| PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex, |
| PerformanceCounterKHRAllocator & performanceCounterKHRAllocator, |
| PerformanceCounterDescriptionKHRAllocator & performanceCounterDescriptionKHRAllocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR && |
| "Function <vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR> requires <VK_KHR_performance_query>" ); |
| # endif |
| |
| std::pair<std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR, PerformanceCounterKHRAllocator>, |
| std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator>> |
| data_( |
| std::piecewise_construct, std::forward_as_tuple( performanceCounterKHRAllocator ), std::forward_as_tuple( performanceCounterDescriptionKHRAllocator ) ); |
| std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR, PerformanceCounterKHRAllocator> & counters = data_.first; |
| std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator> & counterDescriptions = data_.second; |
| uint32_t counterCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( m_physicalDevice, queueFamilyIndex, &counterCount, nullptr, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && counterCount ) |
| { |
| counters.resize( counterCount ); |
| counterDescriptions.resize( counterCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( |
| m_physicalDevice, |
| queueFamilyIndex, |
| &counterCount, |
| reinterpret_cast<VkPerformanceCounterKHR *>( counters.data() ), |
| reinterpret_cast<VkPerformanceCounterDescriptionKHR *>( counterDescriptions.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR" ); |
| VULKAN_HPP_ASSERT( counterCount <= counters.size() ); |
| if ( counterCount < counters.size() ) |
| { |
| counters.resize( counterCount ); |
| counterDescriptions.resize( counterCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data_ ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void |
| PhysicalDevice::getQueueFamilyPerformanceQueryPassesKHR( const VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR * pPerformanceQueryCreateInfo, |
| uint32_t * pNumPasses, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( |
| m_physicalDevice, reinterpret_cast<const VkQueryPoolPerformanceCreateInfoKHR *>( pPerformanceQueryCreateInfo ), pNumPasses ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint32_t PhysicalDevice::getQueueFamilyPerformanceQueryPassesKHR( |
| const VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR & performanceQueryCreateInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR && |
| "Function <vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR> requires <VK_KHR_performance_query>" ); |
| # endif |
| |
| uint32_t numPasses; |
| d.vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( |
| m_physicalDevice, reinterpret_cast<const VkQueryPoolPerformanceCreateInfoKHR *>( &performanceQueryCreateInfo ), &numPasses ); |
| |
| return numPasses; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::acquireProfilingLockKHR( const VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR * pInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkAcquireProfilingLockKHR( m_device, reinterpret_cast<const VkAcquireProfilingLockInfoKHR *>( pInfo ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type |
| Device::acquireProfilingLockKHR( const VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR & info, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkAcquireProfilingLockKHR && "Function <vkAcquireProfilingLockKHR> requires <VK_KHR_performance_query>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = |
| static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkAcquireProfilingLockKHR( m_device, reinterpret_cast<const VkAcquireProfilingLockInfoKHR *>( &info ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::acquireProfilingLockKHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::releaseProfilingLockKHR( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkReleaseProfilingLockKHR( m_device ); |
| } |
| |
| //=== VK_KHR_get_surface_capabilities2 === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| PhysicalDevice::getSurfaceCapabilities2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo, |
| VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR * pSurfaceCapabilities, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilities2KHR( m_physicalDevice, |
| reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( pSurfaceInfo ), |
| reinterpret_cast<VkSurfaceCapabilities2KHR *>( pSurfaceCapabilities ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR>::type |
| PhysicalDevice::getSurfaceCapabilities2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfaceCapabilities2KHR && |
| "Function <vkGetPhysicalDeviceSurfaceCapabilities2KHR> requires <VK_KHR_get_surface_capabilities2>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR surfaceCapabilities; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetPhysicalDeviceSurfaceCapabilities2KHR( m_physicalDevice, |
| reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ), |
| reinterpret_cast<VkSurfaceCapabilities2KHR *>( &surfaceCapabilities ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilities2KHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( surfaceCapabilities ) ); |
| } |
| |
| template <typename X, typename Y, typename... Z, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>>::type |
| PhysicalDevice::getSurfaceCapabilities2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfaceCapabilities2KHR && |
| "Function <vkGetPhysicalDeviceSurfaceCapabilities2KHR> requires <VK_KHR_get_surface_capabilities2>" ); |
| # endif |
| |
| StructureChain<X, Y, Z...> structureChain; |
| VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR & surfaceCapabilities = structureChain.template get<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR>(); |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetPhysicalDeviceSurfaceCapabilities2KHR( m_physicalDevice, |
| reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ), |
| reinterpret_cast<VkSurfaceCapabilities2KHR *>( &surfaceCapabilities ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilities2KHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( structureChain ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo, |
| uint32_t * pSurfaceFormatCount, |
| VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR * pSurfaceFormats, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormats2KHR( m_physicalDevice, |
| reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( pSurfaceInfo ), |
| pSurfaceFormatCount, |
| reinterpret_cast<VkSurfaceFormat2KHR *>( pSurfaceFormats ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename SurfaceFormat2KHRAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR, SurfaceFormat2KHRAllocator>>::type |
| PhysicalDevice::getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfaceFormats2KHR && |
| "Function <vkGetPhysicalDeviceSurfaceFormats2KHR> requires <VK_KHR_get_surface_capabilities2>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR, SurfaceFormat2KHRAllocator> surfaceFormats; |
| uint32_t surfaceFormatCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPhysicalDeviceSurfaceFormats2KHR( |
| m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ), &surfaceFormatCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && surfaceFormatCount ) |
| { |
| surfaceFormats.resize( surfaceFormatCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetPhysicalDeviceSurfaceFormats2KHR( m_physicalDevice, |
| reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ), |
| &surfaceFormatCount, |
| reinterpret_cast<VkSurfaceFormat2KHR *>( surfaceFormats.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceFormats2KHR" ); |
| VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() ); |
| if ( surfaceFormatCount < surfaceFormats.size() ) |
| { |
| surfaceFormats.resize( surfaceFormatCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( surfaceFormats ) ); |
| } |
| |
| template <typename SurfaceFormat2KHRAllocator, |
| typename Dispatch, |
| typename std::enable_if<std::is_same<typename SurfaceFormat2KHRAllocator::value_type, VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR>::value, int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR, SurfaceFormat2KHRAllocator>>::type |
| PhysicalDevice::getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, |
| SurfaceFormat2KHRAllocator & surfaceFormat2KHRAllocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfaceFormats2KHR && |
| "Function <vkGetPhysicalDeviceSurfaceFormats2KHR> requires <VK_KHR_get_surface_capabilities2>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR, SurfaceFormat2KHRAllocator> surfaceFormats( surfaceFormat2KHRAllocator ); |
| uint32_t surfaceFormatCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPhysicalDeviceSurfaceFormats2KHR( |
| m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ), &surfaceFormatCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && surfaceFormatCount ) |
| { |
| surfaceFormats.resize( surfaceFormatCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetPhysicalDeviceSurfaceFormats2KHR( m_physicalDevice, |
| reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ), |
| &surfaceFormatCount, |
| reinterpret_cast<VkSurfaceFormat2KHR *>( surfaceFormats.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceFormats2KHR" ); |
| VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() ); |
| if ( surfaceFormatCount < surfaceFormats.size() ) |
| { |
| surfaceFormats.resize( surfaceFormatCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( surfaceFormats ) ); |
| } |
| |
| template <typename StructureChain, typename StructureChainAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<StructureChain, StructureChainAllocator>>::type |
| PhysicalDevice::getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfaceFormats2KHR && |
| "Function <vkGetPhysicalDeviceSurfaceFormats2KHR> requires <VK_KHR_get_surface_capabilities2>" ); |
| # endif |
| |
| std::vector<StructureChain, StructureChainAllocator> structureChains; |
| std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR> surfaceFormats; |
| uint32_t surfaceFormatCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPhysicalDeviceSurfaceFormats2KHR( |
| m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ), &surfaceFormatCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && surfaceFormatCount ) |
| { |
| structureChains.resize( surfaceFormatCount ); |
| surfaceFormats.resize( surfaceFormatCount ); |
| for ( uint32_t i = 0; i < surfaceFormatCount; i++ ) |
| { |
| surfaceFormats[i].pNext = structureChains[i].template get<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR>().pNext; |
| } |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetPhysicalDeviceSurfaceFormats2KHR( m_physicalDevice, |
| reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ), |
| &surfaceFormatCount, |
| reinterpret_cast<VkSurfaceFormat2KHR *>( surfaceFormats.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceFormats2KHR" ); |
| VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() ); |
| if ( surfaceFormatCount < surfaceFormats.size() ) |
| { |
| structureChains.resize( surfaceFormatCount ); |
| } |
| for ( uint32_t i = 0; i < surfaceFormatCount; i++ ) |
| { |
| structureChains[i].template get<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR>() = surfaceFormats[i]; |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( structureChains ) ); |
| } |
| |
| template <typename StructureChain, |
| typename StructureChainAllocator, |
| typename Dispatch, |
| typename std::enable_if<std::is_same<typename StructureChainAllocator::value_type, StructureChain>::value, int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<StructureChain, StructureChainAllocator>>::type |
| PhysicalDevice::getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, |
| StructureChainAllocator & structureChainAllocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfaceFormats2KHR && |
| "Function <vkGetPhysicalDeviceSurfaceFormats2KHR> requires <VK_KHR_get_surface_capabilities2>" ); |
| # endif |
| |
| std::vector<StructureChain, StructureChainAllocator> structureChains( structureChainAllocator ); |
| std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR> surfaceFormats; |
| uint32_t surfaceFormatCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPhysicalDeviceSurfaceFormats2KHR( |
| m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ), &surfaceFormatCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && surfaceFormatCount ) |
| { |
| structureChains.resize( surfaceFormatCount ); |
| surfaceFormats.resize( surfaceFormatCount ); |
| for ( uint32_t i = 0; i < surfaceFormatCount; i++ ) |
| { |
| surfaceFormats[i].pNext = structureChains[i].template get<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR>().pNext; |
| } |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetPhysicalDeviceSurfaceFormats2KHR( m_physicalDevice, |
| reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ), |
| &surfaceFormatCount, |
| reinterpret_cast<VkSurfaceFormat2KHR *>( surfaceFormats.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceFormats2KHR" ); |
| VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() ); |
| if ( surfaceFormatCount < surfaceFormats.size() ) |
| { |
| structureChains.resize( surfaceFormatCount ); |
| } |
| for ( uint32_t i = 0; i < surfaceFormatCount; i++ ) |
| { |
| structureChains[i].template get<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR>() = surfaceFormats[i]; |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( structureChains ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_KHR_get_display_properties2 === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayProperties2KHR( uint32_t * pPropertyCount, |
| VULKAN_HPP_NAMESPACE::DisplayProperties2KHR * pProperties, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( |
| d.vkGetPhysicalDeviceDisplayProperties2KHR( m_physicalDevice, pPropertyCount, reinterpret_cast<VkDisplayProperties2KHR *>( pProperties ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename DisplayProperties2KHRAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE |
| typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR, DisplayProperties2KHRAllocator>>::type |
| PhysicalDevice::getDisplayProperties2KHR( Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceDisplayProperties2KHR && |
| "Function <vkGetPhysicalDeviceDisplayProperties2KHR> requires <VK_KHR_get_display_properties2>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR, DisplayProperties2KHRAllocator> properties; |
| uint32_t propertyCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPhysicalDeviceDisplayProperties2KHR( m_physicalDevice, &propertyCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount ) |
| { |
| properties.resize( propertyCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetPhysicalDeviceDisplayProperties2KHR( m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayProperties2KHR *>( properties.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayProperties2KHR" ); |
| VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); |
| if ( propertyCount < properties.size() ) |
| { |
| properties.resize( propertyCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); |
| } |
| |
| template < |
| typename DisplayProperties2KHRAllocator, |
| typename Dispatch, |
| typename std::enable_if<std::is_same<typename DisplayProperties2KHRAllocator::value_type, VULKAN_HPP_NAMESPACE::DisplayProperties2KHR>::value, int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE |
| typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR, DisplayProperties2KHRAllocator>>::type |
| PhysicalDevice::getDisplayProperties2KHR( DisplayProperties2KHRAllocator & displayProperties2KHRAllocator, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceDisplayProperties2KHR && |
| "Function <vkGetPhysicalDeviceDisplayProperties2KHR> requires <VK_KHR_get_display_properties2>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR, DisplayProperties2KHRAllocator> properties( displayProperties2KHRAllocator ); |
| uint32_t propertyCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPhysicalDeviceDisplayProperties2KHR( m_physicalDevice, &propertyCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount ) |
| { |
| properties.resize( propertyCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetPhysicalDeviceDisplayProperties2KHR( m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayProperties2KHR *>( properties.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayProperties2KHR" ); |
| VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); |
| if ( propertyCount < properties.size() ) |
| { |
| properties.resize( propertyCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlaneProperties2KHR( uint32_t * pPropertyCount, |
| VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR * pProperties, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( |
| d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR( m_physicalDevice, pPropertyCount, reinterpret_cast<VkDisplayPlaneProperties2KHR *>( pProperties ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename DisplayPlaneProperties2KHRAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE |
| typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR, DisplayPlaneProperties2KHRAllocator>>::type |
| PhysicalDevice::getDisplayPlaneProperties2KHR( Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR && |
| "Function <vkGetPhysicalDeviceDisplayPlaneProperties2KHR> requires <VK_KHR_get_display_properties2>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR, DisplayPlaneProperties2KHRAllocator> properties; |
| uint32_t propertyCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR( m_physicalDevice, &propertyCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount ) |
| { |
| properties.resize( propertyCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR( |
| m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayPlaneProperties2KHR *>( properties.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneProperties2KHR" ); |
| VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); |
| if ( propertyCount < properties.size() ) |
| { |
| properties.resize( propertyCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); |
| } |
| |
| template < |
| typename DisplayPlaneProperties2KHRAllocator, |
| typename Dispatch, |
| typename std::enable_if<std::is_same<typename DisplayPlaneProperties2KHRAllocator::value_type, VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR>::value, |
| int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE |
| typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR, DisplayPlaneProperties2KHRAllocator>>::type |
| PhysicalDevice::getDisplayPlaneProperties2KHR( DisplayPlaneProperties2KHRAllocator & displayPlaneProperties2KHRAllocator, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR && |
| "Function <vkGetPhysicalDeviceDisplayPlaneProperties2KHR> requires <VK_KHR_get_display_properties2>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR, DisplayPlaneProperties2KHRAllocator> properties( displayPlaneProperties2KHRAllocator ); |
| uint32_t propertyCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR( m_physicalDevice, &propertyCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount ) |
| { |
| properties.resize( propertyCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR( |
| m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayPlaneProperties2KHR *>( properties.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneProperties2KHR" ); |
| VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); |
| if ( propertyCount < properties.size() ) |
| { |
| properties.resize( propertyCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayModeProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, |
| uint32_t * pPropertyCount, |
| VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR * pProperties, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetDisplayModeProperties2KHR( |
| m_physicalDevice, static_cast<VkDisplayKHR>( display ), pPropertyCount, reinterpret_cast<VkDisplayModeProperties2KHR *>( pProperties ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename DisplayModeProperties2KHRAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE |
| typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR, DisplayModeProperties2KHRAllocator>>::type |
| PhysicalDevice::getDisplayModeProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetDisplayModeProperties2KHR && "Function <vkGetDisplayModeProperties2KHR> requires <VK_KHR_get_display_properties2>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR, DisplayModeProperties2KHRAllocator> properties; |
| uint32_t propertyCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetDisplayModeProperties2KHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount ) |
| { |
| properties.resize( propertyCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetDisplayModeProperties2KHR( |
| m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, reinterpret_cast<VkDisplayModeProperties2KHR *>( properties.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayModeProperties2KHR" ); |
| VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); |
| if ( propertyCount < properties.size() ) |
| { |
| properties.resize( propertyCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); |
| } |
| |
| template < |
| typename DisplayModeProperties2KHRAllocator, |
| typename Dispatch, |
| typename std::enable_if<std::is_same<typename DisplayModeProperties2KHRAllocator::value_type, VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR>::value, |
| int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE |
| typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR, DisplayModeProperties2KHRAllocator>>::type |
| PhysicalDevice::getDisplayModeProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, |
| DisplayModeProperties2KHRAllocator & displayModeProperties2KHRAllocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetDisplayModeProperties2KHR && "Function <vkGetDisplayModeProperties2KHR> requires <VK_KHR_get_display_properties2>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR, DisplayModeProperties2KHRAllocator> properties( displayModeProperties2KHRAllocator ); |
| uint32_t propertyCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetDisplayModeProperties2KHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount ) |
| { |
| properties.resize( propertyCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetDisplayModeProperties2KHR( |
| m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, reinterpret_cast<VkDisplayModeProperties2KHR *>( properties.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayModeProperties2KHR" ); |
| VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); |
| if ( propertyCount < properties.size() ) |
| { |
| properties.resize( propertyCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| PhysicalDevice::getDisplayPlaneCapabilities2KHR( const VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR * pDisplayPlaneInfo, |
| VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR * pCapabilities, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetDisplayPlaneCapabilities2KHR( m_physicalDevice, |
| reinterpret_cast<const VkDisplayPlaneInfo2KHR *>( pDisplayPlaneInfo ), |
| reinterpret_cast<VkDisplayPlaneCapabilities2KHR *>( pCapabilities ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR>::type |
| PhysicalDevice::getDisplayPlaneCapabilities2KHR( const VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR & displayPlaneInfo, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetDisplayPlaneCapabilities2KHR && "Function <vkGetDisplayPlaneCapabilities2KHR> requires <VK_KHR_get_display_properties2>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR capabilities; |
| VULKAN_HPP_NAMESPACE::Result result = |
| static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetDisplayPlaneCapabilities2KHR( m_physicalDevice, |
| reinterpret_cast<const VkDisplayPlaneInfo2KHR *>( &displayPlaneInfo ), |
| reinterpret_cast<VkDisplayPlaneCapabilities2KHR *>( &capabilities ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneCapabilities2KHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( capabilities ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| #if defined( VK_USE_PLATFORM_IOS_MVK ) |
| //=== VK_MVK_ios_surface === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createIOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateIOSSurfaceMVK( m_instance, |
| reinterpret_cast<const VkIOSSurfaceCreateInfoMVK *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) ); |
| } |
| |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type |
| Instance::createIOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateIOSSurfaceMVK && "Function <vkCreateIOSSurfaceMVK> requires <VK_MVK_ios_surface>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateIOSSurfaceMVK( m_instance, |
| reinterpret_cast<const VkIOSSurfaceCreateInfoMVK *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkSurfaceKHR *>( &surface ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createIOSSurfaceMVK" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( surface ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type |
| Instance::createIOSSurfaceMVKUnique( const VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateIOSSurfaceMVK && "Function <vkCreateIOSSurfaceMVK> requires <VK_MVK_ios_surface>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateIOSSurfaceMVK( m_instance, |
| reinterpret_cast<const VkIOSSurfaceCreateInfoMVK *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkSurfaceKHR *>( &surface ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createIOSSurfaceMVKUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>( surface, ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| #endif /*VK_USE_PLATFORM_IOS_MVK*/ |
| |
| #if defined( VK_USE_PLATFORM_MACOS_MVK ) |
| //=== VK_MVK_macos_surface === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createMacOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateMacOSSurfaceMVK( m_instance, |
| reinterpret_cast<const VkMacOSSurfaceCreateInfoMVK *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) ); |
| } |
| |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type |
| Instance::createMacOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateMacOSSurfaceMVK && "Function <vkCreateMacOSSurfaceMVK> requires <VK_MVK_macos_surface>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateMacOSSurfaceMVK( m_instance, |
| reinterpret_cast<const VkMacOSSurfaceCreateInfoMVK *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkSurfaceKHR *>( &surface ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createMacOSSurfaceMVK" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( surface ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type |
| Instance::createMacOSSurfaceMVKUnique( const VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateMacOSSurfaceMVK && "Function <vkCreateMacOSSurfaceMVK> requires <VK_MVK_macos_surface>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateMacOSSurfaceMVK( m_instance, |
| reinterpret_cast<const VkMacOSSurfaceCreateInfoMVK *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkSurfaceKHR *>( &surface ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createMacOSSurfaceMVKUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>( surface, ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| #endif /*VK_USE_PLATFORM_MACOS_MVK*/ |
| |
| //=== VK_EXT_debug_utils === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::setDebugUtilsObjectNameEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT * pNameInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkSetDebugUtilsObjectNameEXT( m_device, reinterpret_cast<const VkDebugUtilsObjectNameInfoEXT *>( pNameInfo ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type |
| Device::setDebugUtilsObjectNameEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT & nameInfo, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkSetDebugUtilsObjectNameEXT && "Function <vkSetDebugUtilsObjectNameEXT> requires <VK_EXT_debug_utils>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkSetDebugUtilsObjectNameEXT( m_device, reinterpret_cast<const VkDebugUtilsObjectNameInfoEXT *>( &nameInfo ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setDebugUtilsObjectNameEXT" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::setDebugUtilsObjectTagEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT * pTagInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkSetDebugUtilsObjectTagEXT( m_device, reinterpret_cast<const VkDebugUtilsObjectTagInfoEXT *>( pTagInfo ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type |
| Device::setDebugUtilsObjectTagEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT & tagInfo, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkSetDebugUtilsObjectTagEXT && "Function <vkSetDebugUtilsObjectTagEXT> requires <VK_EXT_debug_utils>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkSetDebugUtilsObjectTagEXT( m_device, reinterpret_cast<const VkDebugUtilsObjectTagInfoEXT *>( &tagInfo ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setDebugUtilsObjectTagEXT" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Queue::beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkQueueBeginDebugUtilsLabelEXT( m_queue, reinterpret_cast<const VkDebugUtilsLabelEXT *>( pLabelInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Queue::beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkQueueBeginDebugUtilsLabelEXT && "Function <vkQueueBeginDebugUtilsLabelEXT> requires <VK_EXT_debug_utils>" ); |
| # endif |
| |
| d.vkQueueBeginDebugUtilsLabelEXT( m_queue, reinterpret_cast<const VkDebugUtilsLabelEXT *>( &labelInfo ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Queue::endDebugUtilsLabelEXT( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkQueueEndDebugUtilsLabelEXT( m_queue ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Queue::insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkQueueInsertDebugUtilsLabelEXT( m_queue, reinterpret_cast<const VkDebugUtilsLabelEXT *>( pLabelInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Queue::insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkQueueInsertDebugUtilsLabelEXT && "Function <vkQueueInsertDebugUtilsLabelEXT> requires <VK_EXT_debug_utils>" ); |
| # endif |
| |
| d.vkQueueInsertDebugUtilsLabelEXT( m_queue, reinterpret_cast<const VkDebugUtilsLabelEXT *>( &labelInfo ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdBeginDebugUtilsLabelEXT( m_commandBuffer, reinterpret_cast<const VkDebugUtilsLabelEXT *>( pLabelInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdBeginDebugUtilsLabelEXT && "Function <vkCmdBeginDebugUtilsLabelEXT> requires <VK_EXT_debug_utils>" ); |
| # endif |
| |
| d.vkCmdBeginDebugUtilsLabelEXT( m_commandBuffer, reinterpret_cast<const VkDebugUtilsLabelEXT *>( &labelInfo ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::endDebugUtilsLabelEXT( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdEndDebugUtilsLabelEXT( m_commandBuffer ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdInsertDebugUtilsLabelEXT( m_commandBuffer, reinterpret_cast<const VkDebugUtilsLabelEXT *>( pLabelInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdInsertDebugUtilsLabelEXT && "Function <vkCmdInsertDebugUtilsLabelEXT> requires <VK_EXT_debug_utils>" ); |
| # endif |
| |
| d.vkCmdInsertDebugUtilsLabelEXT( m_commandBuffer, reinterpret_cast<const VkDebugUtilsLabelEXT *>( &labelInfo ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| Instance::createDebugUtilsMessengerEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT * pMessenger, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateDebugUtilsMessengerEXT( m_instance, |
| reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkDebugUtilsMessengerEXT *>( pMessenger ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT>::type |
| Instance::createDebugUtilsMessengerEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateDebugUtilsMessengerEXT && "Function <vkCreateDebugUtilsMessengerEXT> requires <VK_EXT_debug_utils>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateDebugUtilsMessengerEXT( |
| m_instance, |
| reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkDebugUtilsMessengerEXT *>( &messenger ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDebugUtilsMessengerEXT" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( messenger ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT, Dispatch>>::type |
| Instance::createDebugUtilsMessengerEXTUnique( const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateDebugUtilsMessengerEXT && "Function <vkCreateDebugUtilsMessengerEXT> requires <VK_EXT_debug_utils>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateDebugUtilsMessengerEXT( |
| m_instance, |
| reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkDebugUtilsMessengerEXT *>( &messenger ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDebugUtilsMessengerEXTUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT, Dispatch>( messenger, ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Instance::destroyDebugUtilsMessengerEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyDebugUtilsMessengerEXT( |
| m_instance, static_cast<VkDebugUtilsMessengerEXT>( messenger ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Instance::destroyDebugUtilsMessengerEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyDebugUtilsMessengerEXT && "Function <vkDestroyDebugUtilsMessengerEXT> requires <VK_EXT_debug_utils>" ); |
| # endif |
| |
| d.vkDestroyDebugUtilsMessengerEXT( |
| m_instance, |
| static_cast<VkDebugUtilsMessengerEXT>( messenger ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Instance::destroy( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyDebugUtilsMessengerEXT( |
| m_instance, static_cast<VkDebugUtilsMessengerEXT>( messenger ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Instance::destroy( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyDebugUtilsMessengerEXT && "Function <vkDestroyDebugUtilsMessengerEXT> requires <VK_EXT_debug_utils>" ); |
| # endif |
| |
| d.vkDestroyDebugUtilsMessengerEXT( |
| m_instance, |
| static_cast<VkDebugUtilsMessengerEXT>( messenger ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Instance::submitDebugUtilsMessageEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, |
| VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT messageTypes, |
| const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT * pCallbackData, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkSubmitDebugUtilsMessageEXT( m_instance, |
| static_cast<VkDebugUtilsMessageSeverityFlagBitsEXT>( messageSeverity ), |
| static_cast<VkDebugUtilsMessageTypeFlagsEXT>( messageTypes ), |
| reinterpret_cast<const VkDebugUtilsMessengerCallbackDataEXT *>( pCallbackData ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Instance::submitDebugUtilsMessageEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, |
| VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT messageTypes, |
| const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT & callbackData, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkSubmitDebugUtilsMessageEXT && "Function <vkSubmitDebugUtilsMessageEXT> requires <VK_EXT_debug_utils>" ); |
| # endif |
| |
| d.vkSubmitDebugUtilsMessageEXT( m_instance, |
| static_cast<VkDebugUtilsMessageSeverityFlagBitsEXT>( messageSeverity ), |
| static_cast<VkDebugUtilsMessageTypeFlagsEXT>( messageTypes ), |
| reinterpret_cast<const VkDebugUtilsMessengerCallbackDataEXT *>( &callbackData ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| #if defined( VK_USE_PLATFORM_ANDROID_KHR ) |
| //=== VK_ANDROID_external_memory_android_hardware_buffer === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| Device::getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer * buffer, |
| VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID * pProperties, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( |
| d.vkGetAndroidHardwareBufferPropertiesANDROID( m_device, buffer, reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID *>( pProperties ) ) ); |
| } |
| |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID>::type |
| Device::getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetAndroidHardwareBufferPropertiesANDROID && |
| "Function <vkGetAndroidHardwareBufferPropertiesANDROID> requires <VK_ANDROID_external_memory_android_hardware_buffer>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID properties; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetAndroidHardwareBufferPropertiesANDROID( m_device, &buffer, reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID *>( &properties ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getAndroidHardwareBufferPropertiesANDROID" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); |
| } |
| |
| template <typename X, typename Y, typename... Z, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>>::type |
| Device::getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetAndroidHardwareBufferPropertiesANDROID && |
| "Function <vkGetAndroidHardwareBufferPropertiesANDROID> requires <VK_ANDROID_external_memory_android_hardware_buffer>" ); |
| # endif |
| |
| StructureChain<X, Y, Z...> structureChain; |
| VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID & properties = |
| structureChain.template get<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID>(); |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetAndroidHardwareBufferPropertiesANDROID( m_device, &buffer, reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID *>( &properties ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getAndroidHardwareBufferPropertiesANDROID" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( structureChain ) ); |
| } |
| # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| Device::getMemoryAndroidHardwareBufferANDROID( const VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID * pInfo, |
| struct AHardwareBuffer ** pBuffer, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( |
| d.vkGetMemoryAndroidHardwareBufferANDROID( m_device, reinterpret_cast<const VkMemoryGetAndroidHardwareBufferInfoANDROID *>( pInfo ), pBuffer ) ); |
| } |
| |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<struct AHardwareBuffer *>::type |
| Device::getMemoryAndroidHardwareBufferANDROID( const VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID & info, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetMemoryAndroidHardwareBufferANDROID && |
| "Function <vkGetMemoryAndroidHardwareBufferANDROID> requires <VK_ANDROID_external_memory_android_hardware_buffer>" ); |
| # endif |
| |
| struct AHardwareBuffer * buffer; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetMemoryAndroidHardwareBufferANDROID( m_device, reinterpret_cast<const VkMemoryGetAndroidHardwareBufferInfoANDROID *>( &info ), &buffer ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryAndroidHardwareBufferANDROID" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( buffer ) ); |
| } |
| # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ |
| |
| #if defined( VK_ENABLE_BETA_EXTENSIONS ) |
| //=== VK_AMDX_shader_enqueue === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| Device::createExecutionGraphPipelinesAMDX( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, |
| uint32_t createInfoCount, |
| const VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX * pCreateInfos, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::Pipeline * pPipelines, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateExecutionGraphPipelinesAMDX( m_device, |
| static_cast<VkPipelineCache>( pipelineCache ), |
| createInfoCount, |
| reinterpret_cast<const VkExecutionGraphPipelineCreateInfoAMDX *>( pCreateInfos ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkPipeline *>( pPipelines ) ) ); |
| } |
| |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename PipelineAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>> Device::createExecutionGraphPipelinesAMDX( |
| VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX> const & createInfos, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateExecutionGraphPipelinesAMDX && "Function <vkCreateExecutionGraphPipelinesAMDX> requires <VK_AMDX_shader_enqueue>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator> pipelines( createInfos.size() ); |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateExecutionGraphPipelinesAMDX( |
| m_device, |
| static_cast<VkPipelineCache>( pipelineCache ), |
| createInfos.size(), |
| reinterpret_cast<const VkExecutionGraphPipelineCreateInfoAMDX *>( createInfos.data() ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkPipeline *>( pipelines.data() ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createExecutionGraphPipelinesAMDX", |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); |
| |
| return ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>( result, std::move( pipelines ) ); |
| } |
| |
| template <typename PipelineAllocator, |
| typename Dispatch, |
| typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, VULKAN_HPP_NAMESPACE::Pipeline>::value, int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>> Device::createExecutionGraphPipelinesAMDX( |
| VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX> const & createInfos, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| PipelineAllocator & pipelineAllocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateExecutionGraphPipelinesAMDX && "Function <vkCreateExecutionGraphPipelinesAMDX> requires <VK_AMDX_shader_enqueue>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator> pipelines( createInfos.size(), pipelineAllocator ); |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateExecutionGraphPipelinesAMDX( |
| m_device, |
| static_cast<VkPipelineCache>( pipelineCache ), |
| createInfos.size(), |
| reinterpret_cast<const VkExecutionGraphPipelineCreateInfoAMDX *>( createInfos.data() ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkPipeline *>( pipelines.data() ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createExecutionGraphPipelinesAMDX", |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); |
| |
| return ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>( result, std::move( pipelines ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<VULKAN_HPP_NAMESPACE::Pipeline> |
| Device::createExecutionGraphPipelineAMDX( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, |
| const VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateExecutionGraphPipelinesAMDX && "Function <vkCreateExecutionGraphPipelinesAMDX> requires <VK_AMDX_shader_enqueue>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Pipeline pipeline; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateExecutionGraphPipelinesAMDX( |
| m_device, |
| static_cast<VkPipelineCache>( pipelineCache ), |
| 1, |
| reinterpret_cast<const VkExecutionGraphPipelineCreateInfoAMDX *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkPipeline *>( &pipeline ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createExecutionGraphPipelineAMDX", |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); |
| |
| return ResultValue<VULKAN_HPP_NAMESPACE::Pipeline>( result, std::move( pipeline ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch, typename PipelineAllocator> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>> |
| Device::createExecutionGraphPipelinesAMDXUnique( |
| VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX> const & createInfos, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateExecutionGraphPipelinesAMDX && "Function <vkCreateExecutionGraphPipelinesAMDX> requires <VK_AMDX_shader_enqueue>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::Pipeline> pipelines( createInfos.size() ); |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateExecutionGraphPipelinesAMDX( |
| m_device, |
| static_cast<VkPipelineCache>( pipelineCache ), |
| createInfos.size(), |
| reinterpret_cast<const VkExecutionGraphPipelineCreateInfoAMDX *>( createInfos.data() ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkPipeline *>( pipelines.data() ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createExecutionGraphPipelinesAMDXUnique", |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); |
| std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator> uniquePipelines; |
| uniquePipelines.reserve( createInfos.size() ); |
| ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d ); |
| for ( auto const & pipeline : pipelines ) |
| { |
| uniquePipelines.push_back( UniqueHandle<Pipeline, Dispatch>( pipeline, deleter ) ); |
| } |
| return ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>( result, std::move( uniquePipelines ) ); |
| } |
| |
| template < |
| typename Dispatch, |
| typename PipelineAllocator, |
| typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>::value, int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>> |
| Device::createExecutionGraphPipelinesAMDXUnique( |
| VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX> const & createInfos, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| PipelineAllocator & pipelineAllocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateExecutionGraphPipelinesAMDX && "Function <vkCreateExecutionGraphPipelinesAMDX> requires <VK_AMDX_shader_enqueue>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::Pipeline> pipelines( createInfos.size() ); |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateExecutionGraphPipelinesAMDX( |
| m_device, |
| static_cast<VkPipelineCache>( pipelineCache ), |
| createInfos.size(), |
| reinterpret_cast<const VkExecutionGraphPipelineCreateInfoAMDX *>( createInfos.data() ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkPipeline *>( pipelines.data() ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createExecutionGraphPipelinesAMDXUnique", |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); |
| std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator> uniquePipelines( pipelineAllocator ); |
| uniquePipelines.reserve( createInfos.size() ); |
| ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d ); |
| for ( auto const & pipeline : pipelines ) |
| { |
| uniquePipelines.push_back( UniqueHandle<Pipeline, Dispatch>( pipeline, deleter ) ); |
| } |
| return ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>( result, std::move( uniquePipelines ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>> |
| Device::createExecutionGraphPipelineAMDXUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, |
| const VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateExecutionGraphPipelinesAMDX && "Function <vkCreateExecutionGraphPipelinesAMDX> requires <VK_AMDX_shader_enqueue>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Pipeline pipeline; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateExecutionGraphPipelinesAMDX( |
| m_device, |
| static_cast<VkPipelineCache>( pipelineCache ), |
| 1, |
| reinterpret_cast<const VkExecutionGraphPipelineCreateInfoAMDX *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkPipeline *>( &pipeline ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createExecutionGraphPipelineAMDXUnique", |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); |
| |
| return ResultValue<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>( pipeline, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| Device::getExecutionGraphPipelineScratchSizeAMDX( VULKAN_HPP_NAMESPACE::Pipeline executionGraph, |
| VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineScratchSizeAMDX * pSizeInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetExecutionGraphPipelineScratchSizeAMDX( |
| m_device, static_cast<VkPipeline>( executionGraph ), reinterpret_cast<VkExecutionGraphPipelineScratchSizeAMDX *>( pSizeInfo ) ) ); |
| } |
| |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineScratchSizeAMDX>::type |
| Device::getExecutionGraphPipelineScratchSizeAMDX( VULKAN_HPP_NAMESPACE::Pipeline executionGraph, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetExecutionGraphPipelineScratchSizeAMDX && |
| "Function <vkGetExecutionGraphPipelineScratchSizeAMDX> requires <VK_AMDX_shader_enqueue>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineScratchSizeAMDX sizeInfo; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetExecutionGraphPipelineScratchSizeAMDX( |
| m_device, static_cast<VkPipeline>( executionGraph ), reinterpret_cast<VkExecutionGraphPipelineScratchSizeAMDX *>( &sizeInfo ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getExecutionGraphPipelineScratchSizeAMDX" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( sizeInfo ) ); |
| } |
| # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| Device::getExecutionGraphPipelineNodeIndexAMDX( VULKAN_HPP_NAMESPACE::Pipeline executionGraph, |
| const VULKAN_HPP_NAMESPACE::PipelineShaderStageNodeCreateInfoAMDX * pNodeInfo, |
| uint32_t * pNodeIndex, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetExecutionGraphPipelineNodeIndexAMDX( |
| m_device, static_cast<VkPipeline>( executionGraph ), reinterpret_cast<const VkPipelineShaderStageNodeCreateInfoAMDX *>( pNodeInfo ), pNodeIndex ) ); |
| } |
| |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<uint32_t>::type Device::getExecutionGraphPipelineNodeIndexAMDX( |
| VULKAN_HPP_NAMESPACE::Pipeline executionGraph, const VULKAN_HPP_NAMESPACE::PipelineShaderStageNodeCreateInfoAMDX & nodeInfo, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetExecutionGraphPipelineNodeIndexAMDX && "Function <vkGetExecutionGraphPipelineNodeIndexAMDX> requires <VK_AMDX_shader_enqueue>" ); |
| # endif |
| |
| uint32_t nodeIndex; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetExecutionGraphPipelineNodeIndexAMDX( |
| m_device, static_cast<VkPipeline>( executionGraph ), reinterpret_cast<const VkPipelineShaderStageNodeCreateInfoAMDX *>( &nodeInfo ), &nodeIndex ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getExecutionGraphPipelineNodeIndexAMDX" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( nodeIndex ) ); |
| } |
| # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::initializeGraphScratchMemoryAMDX( VULKAN_HPP_NAMESPACE::DeviceAddress scratch, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdInitializeGraphScratchMemoryAMDX( m_commandBuffer, static_cast<VkDeviceAddress>( scratch ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::dispatchGraphAMDX( VULKAN_HPP_NAMESPACE::DeviceAddress scratch, |
| const VULKAN_HPP_NAMESPACE::DispatchGraphCountInfoAMDX * pCountInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdDispatchGraphAMDX( m_commandBuffer, static_cast<VkDeviceAddress>( scratch ), reinterpret_cast<const VkDispatchGraphCountInfoAMDX *>( pCountInfo ) ); |
| } |
| |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::dispatchGraphAMDX( VULKAN_HPP_NAMESPACE::DeviceAddress scratch, |
| const VULKAN_HPP_NAMESPACE::DispatchGraphCountInfoAMDX & countInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdDispatchGraphAMDX && "Function <vkCmdDispatchGraphAMDX> requires <VK_AMDX_shader_enqueue>" ); |
| # endif |
| |
| d.vkCmdDispatchGraphAMDX( m_commandBuffer, static_cast<VkDeviceAddress>( scratch ), reinterpret_cast<const VkDispatchGraphCountInfoAMDX *>( &countInfo ) ); |
| } |
| # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::dispatchGraphIndirectAMDX( VULKAN_HPP_NAMESPACE::DeviceAddress scratch, |
| const VULKAN_HPP_NAMESPACE::DispatchGraphCountInfoAMDX * pCountInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdDispatchGraphIndirectAMDX( |
| m_commandBuffer, static_cast<VkDeviceAddress>( scratch ), reinterpret_cast<const VkDispatchGraphCountInfoAMDX *>( pCountInfo ) ); |
| } |
| |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::dispatchGraphIndirectAMDX( VULKAN_HPP_NAMESPACE::DeviceAddress scratch, |
| const VULKAN_HPP_NAMESPACE::DispatchGraphCountInfoAMDX & countInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdDispatchGraphIndirectAMDX && "Function <vkCmdDispatchGraphIndirectAMDX> requires <VK_AMDX_shader_enqueue>" ); |
| # endif |
| |
| d.vkCmdDispatchGraphIndirectAMDX( |
| m_commandBuffer, static_cast<VkDeviceAddress>( scratch ), reinterpret_cast<const VkDispatchGraphCountInfoAMDX *>( &countInfo ) ); |
| } |
| # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::dispatchGraphIndirectCountAMDX( VULKAN_HPP_NAMESPACE::DeviceAddress scratch, |
| VULKAN_HPP_NAMESPACE::DeviceAddress countInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdDispatchGraphIndirectCountAMDX( m_commandBuffer, static_cast<VkDeviceAddress>( scratch ), static_cast<VkDeviceAddress>( countInfo ) ); |
| } |
| #endif /*VK_ENABLE_BETA_EXTENSIONS*/ |
| |
| //=== VK_EXT_sample_locations === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setSampleLocationsEXT( const VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT * pSampleLocationsInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetSampleLocationsEXT( m_commandBuffer, reinterpret_cast<const VkSampleLocationsInfoEXT *>( pSampleLocationsInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setSampleLocationsEXT( const VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT & sampleLocationsInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdSetSampleLocationsEXT && "Function <vkCmdSetSampleLocationsEXT> requires <VK_EXT_sample_locations>" ); |
| # endif |
| |
| d.vkCmdSetSampleLocationsEXT( m_commandBuffer, reinterpret_cast<const VkSampleLocationsInfoEXT *>( &sampleLocationsInfo ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void PhysicalDevice::getMultisamplePropertiesEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples, |
| VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT * pMultisampleProperties, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetPhysicalDeviceMultisamplePropertiesEXT( |
| m_physicalDevice, static_cast<VkSampleCountFlagBits>( samples ), reinterpret_cast<VkMultisamplePropertiesEXT *>( pMultisampleProperties ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT |
| PhysicalDevice::getMultisamplePropertiesEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceMultisamplePropertiesEXT && |
| "Function <vkGetPhysicalDeviceMultisamplePropertiesEXT> requires <VK_EXT_sample_locations>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT multisampleProperties; |
| d.vkGetPhysicalDeviceMultisamplePropertiesEXT( |
| m_physicalDevice, static_cast<VkSampleCountFlagBits>( samples ), reinterpret_cast<VkMultisamplePropertiesEXT *>( &multisampleProperties ) ); |
| |
| return multisampleProperties; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_KHR_get_memory_requirements2 === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::getImageMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 * pInfo, |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetImageMemoryRequirements2KHR( |
| m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>( pInfo ), reinterpret_cast<VkMemoryRequirements2 *>( pMemoryRequirements ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2 |
| Device::getImageMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetImageMemoryRequirements2KHR && |
| "Function <vkGetImageMemoryRequirements2KHR> requires <VK_KHR_get_memory_requirements2> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements; |
| d.vkGetImageMemoryRequirements2KHR( |
| m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>( &info ), reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) ); |
| |
| return memoryRequirements; |
| } |
| |
| template <typename X, typename Y, typename... Z, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> |
| Device::getImageMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetImageMemoryRequirements2KHR && |
| "Function <vkGetImageMemoryRequirements2KHR> requires <VK_KHR_get_memory_requirements2> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain; |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>(); |
| d.vkGetImageMemoryRequirements2KHR( |
| m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>( &info ), reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) ); |
| |
| return structureChain; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::getBufferMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 * pInfo, |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetBufferMemoryRequirements2KHR( |
| m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>( pInfo ), reinterpret_cast<VkMemoryRequirements2 *>( pMemoryRequirements ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2 |
| Device::getBufferMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetBufferMemoryRequirements2KHR && |
| "Function <vkGetBufferMemoryRequirements2KHR> requires <VK_KHR_get_memory_requirements2> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements; |
| d.vkGetBufferMemoryRequirements2KHR( |
| m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>( &info ), reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) ); |
| |
| return memoryRequirements; |
| } |
| |
| template <typename X, typename Y, typename... Z, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> |
| Device::getBufferMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetBufferMemoryRequirements2KHR && |
| "Function <vkGetBufferMemoryRequirements2KHR> requires <VK_KHR_get_memory_requirements2> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain; |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>(); |
| d.vkGetBufferMemoryRequirements2KHR( |
| m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>( &info ), reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) ); |
| |
| return structureChain; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 * pInfo, |
| uint32_t * pSparseMemoryRequirementCount, |
| VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 * pSparseMemoryRequirements, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetImageSparseMemoryRequirements2KHR( m_device, |
| reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( pInfo ), |
| pSparseMemoryRequirementCount, |
| reinterpret_cast<VkSparseImageMemoryRequirements2 *>( pSparseMemoryRequirements ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename SparseImageMemoryRequirements2Allocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> |
| Device::getImageSparseMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetImageSparseMemoryRequirements2KHR && |
| "Function <vkGetImageSparseMemoryRequirements2KHR> requires <VK_KHR_get_memory_requirements2> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> sparseMemoryRequirements; |
| uint32_t sparseMemoryRequirementCount; |
| d.vkGetImageSparseMemoryRequirements2KHR( |
| m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ), &sparseMemoryRequirementCount, nullptr ); |
| sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); |
| d.vkGetImageSparseMemoryRequirements2KHR( m_device, |
| reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ), |
| &sparseMemoryRequirementCount, |
| reinterpret_cast<VkSparseImageMemoryRequirements2 *>( sparseMemoryRequirements.data() ) ); |
| |
| VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() ); |
| if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() ) |
| { |
| sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); |
| } |
| return sparseMemoryRequirements; |
| } |
| |
| template <typename SparseImageMemoryRequirements2Allocator, |
| typename Dispatch, |
| typename std::enable_if< |
| std::is_same<typename SparseImageMemoryRequirements2Allocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>::value, |
| int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> |
| Device::getImageSparseMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info, |
| SparseImageMemoryRequirements2Allocator & sparseImageMemoryRequirements2Allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetImageSparseMemoryRequirements2KHR && |
| "Function <vkGetImageSparseMemoryRequirements2KHR> requires <VK_KHR_get_memory_requirements2> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> sparseMemoryRequirements( |
| sparseImageMemoryRequirements2Allocator ); |
| uint32_t sparseMemoryRequirementCount; |
| d.vkGetImageSparseMemoryRequirements2KHR( |
| m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ), &sparseMemoryRequirementCount, nullptr ); |
| sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); |
| d.vkGetImageSparseMemoryRequirements2KHR( m_device, |
| reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ), |
| &sparseMemoryRequirementCount, |
| reinterpret_cast<VkSparseImageMemoryRequirements2 *>( sparseMemoryRequirements.data() ) ); |
| |
| VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() ); |
| if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() ) |
| { |
| sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); |
| } |
| return sparseMemoryRequirements; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_KHR_acceleration_structure === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| Device::createAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::AccelerationStructureKHR * pAccelerationStructure, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateAccelerationStructureKHR( m_device, |
| reinterpret_cast<const VkAccelerationStructureCreateInfoKHR *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkAccelerationStructureKHR *>( pAccelerationStructure ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR>::type |
| Device::createAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateAccelerationStructureKHR && "Function <vkCreateAccelerationStructureKHR> requires <VK_KHR_acceleration_structure>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateAccelerationStructureKHR( |
| m_device, |
| reinterpret_cast<const VkAccelerationStructureCreateInfoKHR *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkAccelerationStructureKHR *>( &accelerationStructure ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createAccelerationStructureKHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( accelerationStructure ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR, Dispatch>>::type |
| Device::createAccelerationStructureKHRUnique( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateAccelerationStructureKHR && "Function <vkCreateAccelerationStructureKHR> requires <VK_KHR_acceleration_structure>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateAccelerationStructureKHR( |
| m_device, |
| reinterpret_cast<const VkAccelerationStructureCreateInfoKHR *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkAccelerationStructureKHR *>( &accelerationStructure ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createAccelerationStructureKHRUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( |
| result, |
| UniqueHandle<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR, Dispatch>( accelerationStructure, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyAccelerationStructureKHR( |
| m_device, static_cast<VkAccelerationStructureKHR>( accelerationStructure ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyAccelerationStructureKHR && "Function <vkDestroyAccelerationStructureKHR> requires <VK_KHR_acceleration_structure>" ); |
| # endif |
| |
| d.vkDestroyAccelerationStructureKHR( |
| m_device, |
| static_cast<VkAccelerationStructureKHR>( accelerationStructure ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyAccelerationStructureKHR( |
| m_device, static_cast<VkAccelerationStructureKHR>( accelerationStructure ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyAccelerationStructureKHR && "Function <vkDestroyAccelerationStructureKHR> requires <VK_KHR_acceleration_structure>" ); |
| # endif |
| |
| d.vkDestroyAccelerationStructureKHR( |
| m_device, |
| static_cast<VkAccelerationStructureKHR>( accelerationStructure ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void |
| CommandBuffer::buildAccelerationStructuresKHR( uint32_t infoCount, |
| const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR * pInfos, |
| const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdBuildAccelerationStructuresKHR( m_commandBuffer, |
| infoCount, |
| reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>( pInfos ), |
| reinterpret_cast<const VkAccelerationStructureBuildRangeInfoKHR * const *>( ppBuildRangeInfos ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructuresKHR( |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const> const & pBuildRangeInfos, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdBuildAccelerationStructuresKHR && "Function <vkCmdBuildAccelerationStructuresKHR> requires <VK_KHR_acceleration_structure>" ); |
| # endif |
| # ifdef VULKAN_HPP_NO_EXCEPTIONS |
| VULKAN_HPP_ASSERT( infos.size() == pBuildRangeInfos.size() ); |
| # else |
| if ( infos.size() != pBuildRangeInfos.size() ) |
| { |
| throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::buildAccelerationStructuresKHR: infos.size() != pBuildRangeInfos.size()" ); |
| } |
| # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ |
| |
| d.vkCmdBuildAccelerationStructuresKHR( m_commandBuffer, |
| infos.size(), |
| reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>( infos.data() ), |
| reinterpret_cast<const VkAccelerationStructureBuildRangeInfoKHR * const *>( pBuildRangeInfos.data() ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructuresIndirectKHR( uint32_t infoCount, |
| const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR * pInfos, |
| const VULKAN_HPP_NAMESPACE::DeviceAddress * pIndirectDeviceAddresses, |
| const uint32_t * pIndirectStrides, |
| const uint32_t * const * ppMaxPrimitiveCounts, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdBuildAccelerationStructuresIndirectKHR( m_commandBuffer, |
| infoCount, |
| reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>( pInfos ), |
| reinterpret_cast<const VkDeviceAddress *>( pIndirectDeviceAddresses ), |
| pIndirectStrides, |
| ppMaxPrimitiveCounts ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructuresIndirectKHR( |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceAddress> const & indirectDeviceAddresses, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t> const & indirectStrides, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t * const> const & pMaxPrimitiveCounts, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdBuildAccelerationStructuresIndirectKHR && |
| "Function <vkCmdBuildAccelerationStructuresIndirectKHR> requires <VK_KHR_acceleration_structure>" ); |
| # endif |
| # ifdef VULKAN_HPP_NO_EXCEPTIONS |
| VULKAN_HPP_ASSERT( infos.size() == indirectDeviceAddresses.size() ); |
| VULKAN_HPP_ASSERT( infos.size() == indirectStrides.size() ); |
| VULKAN_HPP_ASSERT( infos.size() == pMaxPrimitiveCounts.size() ); |
| # else |
| if ( infos.size() != indirectDeviceAddresses.size() ) |
| { |
| throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::buildAccelerationStructuresIndirectKHR: infos.size() != indirectDeviceAddresses.size()" ); |
| } |
| if ( infos.size() != indirectStrides.size() ) |
| { |
| throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::buildAccelerationStructuresIndirectKHR: infos.size() != indirectStrides.size()" ); |
| } |
| if ( infos.size() != pMaxPrimitiveCounts.size() ) |
| { |
| throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::buildAccelerationStructuresIndirectKHR: infos.size() != pMaxPrimitiveCounts.size()" ); |
| } |
| # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ |
| |
| d.vkCmdBuildAccelerationStructuresIndirectKHR( m_commandBuffer, |
| infos.size(), |
| reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>( infos.data() ), |
| reinterpret_cast<const VkDeviceAddress *>( indirectDeviceAddresses.data() ), |
| indirectStrides.data(), |
| pMaxPrimitiveCounts.data() ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| Device::buildAccelerationStructuresKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, |
| uint32_t infoCount, |
| const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR * pInfos, |
| const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( |
| d.vkBuildAccelerationStructuresKHR( m_device, |
| static_cast<VkDeferredOperationKHR>( deferredOperation ), |
| infoCount, |
| reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>( pInfos ), |
| reinterpret_cast<const VkAccelerationStructureBuildRangeInfoKHR * const *>( ppBuildRangeInfos ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result Device::buildAccelerationStructuresKHR( |
| VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const> const & pBuildRangeInfos, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkBuildAccelerationStructuresKHR && "Function <vkBuildAccelerationStructuresKHR> requires <VK_KHR_acceleration_structure>" ); |
| # endif |
| # ifdef VULKAN_HPP_NO_EXCEPTIONS |
| VULKAN_HPP_ASSERT( infos.size() == pBuildRangeInfos.size() ); |
| # else |
| if ( infos.size() != pBuildRangeInfos.size() ) |
| { |
| throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::Device::buildAccelerationStructuresKHR: infos.size() != pBuildRangeInfos.size()" ); |
| } |
| # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkBuildAccelerationStructuresKHR( m_device, |
| static_cast<VkDeferredOperationKHR>( deferredOperation ), |
| infos.size(), |
| reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>( infos.data() ), |
| reinterpret_cast<const VkAccelerationStructureBuildRangeInfoKHR * const *>( pBuildRangeInfos.data() ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( |
| result, |
| VULKAN_HPP_NAMESPACE_STRING "::Device::buildAccelerationStructuresKHR", |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR, VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR } ); |
| |
| return static_cast<VULKAN_HPP_NAMESPACE::Result>( result ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, |
| const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR * pInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCopyAccelerationStructureKHR( |
| m_device, static_cast<VkDeferredOperationKHR>( deferredOperation ), reinterpret_cast<const VkCopyAccelerationStructureInfoKHR *>( pInfo ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result |
| Device::copyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, |
| const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR & info, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCopyAccelerationStructureKHR && "Function <vkCopyAccelerationStructureKHR> requires <VK_KHR_acceleration_structure>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCopyAccelerationStructureKHR( |
| m_device, static_cast<VkDeferredOperationKHR>( deferredOperation ), reinterpret_cast<const VkCopyAccelerationStructureInfoKHR *>( &info ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( |
| result, |
| VULKAN_HPP_NAMESPACE_STRING "::Device::copyAccelerationStructureKHR", |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR, VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR } ); |
| |
| return static_cast<VULKAN_HPP_NAMESPACE::Result>( result ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| Device::copyAccelerationStructureToMemoryKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, |
| const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR * pInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCopyAccelerationStructureToMemoryKHR( |
| m_device, static_cast<VkDeferredOperationKHR>( deferredOperation ), reinterpret_cast<const VkCopyAccelerationStructureToMemoryInfoKHR *>( pInfo ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result |
| Device::copyAccelerationStructureToMemoryKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, |
| const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR & info, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCopyAccelerationStructureToMemoryKHR && |
| "Function <vkCopyAccelerationStructureToMemoryKHR> requires <VK_KHR_acceleration_structure>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCopyAccelerationStructureToMemoryKHR( |
| m_device, static_cast<VkDeferredOperationKHR>( deferredOperation ), reinterpret_cast<const VkCopyAccelerationStructureToMemoryInfoKHR *>( &info ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( |
| result, |
| VULKAN_HPP_NAMESPACE_STRING "::Device::copyAccelerationStructureToMemoryKHR", |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR, VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR } ); |
| |
| return static_cast<VULKAN_HPP_NAMESPACE::Result>( result ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| Device::copyMemoryToAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, |
| const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR * pInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCopyMemoryToAccelerationStructureKHR( |
| m_device, static_cast<VkDeferredOperationKHR>( deferredOperation ), reinterpret_cast<const VkCopyMemoryToAccelerationStructureInfoKHR *>( pInfo ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result |
| Device::copyMemoryToAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, |
| const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR & info, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCopyMemoryToAccelerationStructureKHR && |
| "Function <vkCopyMemoryToAccelerationStructureKHR> requires <VK_KHR_acceleration_structure>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCopyMemoryToAccelerationStructureKHR( |
| m_device, static_cast<VkDeferredOperationKHR>( deferredOperation ), reinterpret_cast<const VkCopyMemoryToAccelerationStructureInfoKHR *>( &info ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( |
| result, |
| VULKAN_HPP_NAMESPACE_STRING "::Device::copyMemoryToAccelerationStructureKHR", |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR, VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR } ); |
| |
| return static_cast<VULKAN_HPP_NAMESPACE::Result>( result ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| Device::writeAccelerationStructuresPropertiesKHR( uint32_t accelerationStructureCount, |
| const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR * pAccelerationStructures, |
| VULKAN_HPP_NAMESPACE::QueryType queryType, |
| size_t dataSize, |
| void * pData, |
| size_t stride, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkWriteAccelerationStructuresPropertiesKHR( m_device, |
| accelerationStructureCount, |
| reinterpret_cast<const VkAccelerationStructureKHR *>( pAccelerationStructures ), |
| static_cast<VkQueryType>( queryType ), |
| dataSize, |
| pData, |
| stride ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename DataType, typename DataTypeAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type |
| Device::writeAccelerationStructuresPropertiesKHR( |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures, |
| VULKAN_HPP_NAMESPACE::QueryType queryType, |
| size_t dataSize, |
| size_t stride, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkWriteAccelerationStructuresPropertiesKHR && |
| "Function <vkWriteAccelerationStructuresPropertiesKHR> requires <VK_KHR_acceleration_structure>" ); |
| # endif |
| |
| VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 ); |
| std::vector<DataType, DataTypeAllocator> data( dataSize / sizeof( DataType ) ); |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkWriteAccelerationStructuresPropertiesKHR( m_device, |
| accelerationStructures.size(), |
| reinterpret_cast<const VkAccelerationStructureKHR *>( accelerationStructures.data() ), |
| static_cast<VkQueryType>( queryType ), |
| data.size() * sizeof( DataType ), |
| reinterpret_cast<void *>( data.data() ), |
| stride ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::writeAccelerationStructuresPropertiesKHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); |
| } |
| |
| template <typename DataType, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<DataType>::type Device::writeAccelerationStructuresPropertyKHR( |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures, |
| VULKAN_HPP_NAMESPACE::QueryType queryType, |
| size_t stride, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkWriteAccelerationStructuresPropertiesKHR && |
| "Function <vkWriteAccelerationStructuresPropertiesKHR> requires <VK_KHR_acceleration_structure>" ); |
| # endif |
| |
| DataType data; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkWriteAccelerationStructuresPropertiesKHR( m_device, |
| accelerationStructures.size(), |
| reinterpret_cast<const VkAccelerationStructureKHR *>( accelerationStructures.data() ), |
| static_cast<VkQueryType>( queryType ), |
| sizeof( DataType ), |
| reinterpret_cast<void *>( &data ), |
| stride ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::writeAccelerationStructuresPropertyKHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR * pInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdCopyAccelerationStructureKHR( m_commandBuffer, reinterpret_cast<const VkCopyAccelerationStructureInfoKHR *>( pInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR & info, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdCopyAccelerationStructureKHR && "Function <vkCmdCopyAccelerationStructureKHR> requires <VK_KHR_acceleration_structure>" ); |
| # endif |
| |
| d.vkCmdCopyAccelerationStructureKHR( m_commandBuffer, reinterpret_cast<const VkCopyAccelerationStructureInfoKHR *>( &info ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureToMemoryKHR( const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR * pInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdCopyAccelerationStructureToMemoryKHR( m_commandBuffer, reinterpret_cast<const VkCopyAccelerationStructureToMemoryInfoKHR *>( pInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureToMemoryKHR( const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR & info, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdCopyAccelerationStructureToMemoryKHR && |
| "Function <vkCmdCopyAccelerationStructureToMemoryKHR> requires <VK_KHR_acceleration_structure>" ); |
| # endif |
| |
| d.vkCmdCopyAccelerationStructureToMemoryKHR( m_commandBuffer, reinterpret_cast<const VkCopyAccelerationStructureToMemoryInfoKHR *>( &info ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::copyMemoryToAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR * pInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdCopyMemoryToAccelerationStructureKHR( m_commandBuffer, reinterpret_cast<const VkCopyMemoryToAccelerationStructureInfoKHR *>( pInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::copyMemoryToAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR & info, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdCopyMemoryToAccelerationStructureKHR && |
| "Function <vkCmdCopyMemoryToAccelerationStructureKHR> requires <VK_KHR_acceleration_structure>" ); |
| # endif |
| |
| d.vkCmdCopyMemoryToAccelerationStructureKHR( m_commandBuffer, reinterpret_cast<const VkCopyMemoryToAccelerationStructureInfoKHR *>( &info ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE DeviceAddress Device::getAccelerationStructureAddressKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR * pInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<DeviceAddress>( |
| d.vkGetAccelerationStructureDeviceAddressKHR( m_device, reinterpret_cast<const VkAccelerationStructureDeviceAddressInfoKHR *>( pInfo ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceAddress |
| Device::getAccelerationStructureAddressKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR & info, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetAccelerationStructureDeviceAddressKHR && |
| "Function <vkGetAccelerationStructureDeviceAddressKHR> requires <VK_KHR_acceleration_structure>" ); |
| # endif |
| |
| VkDeviceAddress result = |
| d.vkGetAccelerationStructureDeviceAddressKHR( m_device, reinterpret_cast<const VkAccelerationStructureDeviceAddressInfoKHR *>( &info ) ); |
| |
| return static_cast<VULKAN_HPP_NAMESPACE::DeviceAddress>( result ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void |
| CommandBuffer::writeAccelerationStructuresPropertiesKHR( uint32_t accelerationStructureCount, |
| const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR * pAccelerationStructures, |
| VULKAN_HPP_NAMESPACE::QueryType queryType, |
| VULKAN_HPP_NAMESPACE::QueryPool queryPool, |
| uint32_t firstQuery, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdWriteAccelerationStructuresPropertiesKHR( m_commandBuffer, |
| accelerationStructureCount, |
| reinterpret_cast<const VkAccelerationStructureKHR *>( pAccelerationStructures ), |
| static_cast<VkQueryType>( queryType ), |
| static_cast<VkQueryPool>( queryPool ), |
| firstQuery ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesKHR( |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures, |
| VULKAN_HPP_NAMESPACE::QueryType queryType, |
| VULKAN_HPP_NAMESPACE::QueryPool queryPool, |
| uint32_t firstQuery, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdWriteAccelerationStructuresPropertiesKHR && |
| "Function <vkCmdWriteAccelerationStructuresPropertiesKHR> requires <VK_KHR_acceleration_structure>" ); |
| # endif |
| |
| d.vkCmdWriteAccelerationStructuresPropertiesKHR( m_commandBuffer, |
| accelerationStructures.size(), |
| reinterpret_cast<const VkAccelerationStructureKHR *>( accelerationStructures.data() ), |
| static_cast<VkQueryType>( queryType ), |
| static_cast<VkQueryPool>( queryPool ), |
| firstQuery ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::getAccelerationStructureCompatibilityKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR * pVersionInfo, |
| VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR * pCompatibility, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetDeviceAccelerationStructureCompatibilityKHR( m_device, |
| reinterpret_cast<const VkAccelerationStructureVersionInfoKHR *>( pVersionInfo ), |
| reinterpret_cast<VkAccelerationStructureCompatibilityKHR *>( pCompatibility ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR |
| Device::getAccelerationStructureCompatibilityKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR & versionInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetDeviceAccelerationStructureCompatibilityKHR && |
| "Function <vkGetDeviceAccelerationStructureCompatibilityKHR> requires <VK_KHR_acceleration_structure>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR compatibility; |
| d.vkGetDeviceAccelerationStructureCompatibilityKHR( m_device, |
| reinterpret_cast<const VkAccelerationStructureVersionInfoKHR *>( &versionInfo ), |
| reinterpret_cast<VkAccelerationStructureCompatibilityKHR *>( &compatibility ) ); |
| |
| return compatibility; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::getAccelerationStructureBuildSizesKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR buildType, |
| const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR * pBuildInfo, |
| const uint32_t * pMaxPrimitiveCounts, |
| VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR * pSizeInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetAccelerationStructureBuildSizesKHR( m_device, |
| static_cast<VkAccelerationStructureBuildTypeKHR>( buildType ), |
| reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>( pBuildInfo ), |
| pMaxPrimitiveCounts, |
| reinterpret_cast<VkAccelerationStructureBuildSizesInfoKHR *>( pSizeInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR |
| Device::getAccelerationStructureBuildSizesKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR buildType, |
| const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR & buildInfo, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t> const & maxPrimitiveCounts, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetAccelerationStructureBuildSizesKHR && |
| "Function <vkGetAccelerationStructureBuildSizesKHR> requires <VK_KHR_acceleration_structure>" ); |
| # endif |
| # ifdef VULKAN_HPP_NO_EXCEPTIONS |
| VULKAN_HPP_ASSERT( maxPrimitiveCounts.size() == buildInfo.geometryCount ); |
| # else |
| if ( maxPrimitiveCounts.size() != buildInfo.geometryCount ) |
| { |
| throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::Device::getAccelerationStructureBuildSizesKHR: maxPrimitiveCounts.size() != buildInfo.geometryCount" ); |
| } |
| # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ |
| |
| VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR sizeInfo; |
| d.vkGetAccelerationStructureBuildSizesKHR( m_device, |
| static_cast<VkAccelerationStructureBuildTypeKHR>( buildType ), |
| reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>( &buildInfo ), |
| maxPrimitiveCounts.data(), |
| reinterpret_cast<VkAccelerationStructureBuildSizesInfoKHR *>( &sizeInfo ) ); |
| |
| return sizeInfo; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_KHR_ray_tracing_pipeline === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::traceRaysKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pRaygenShaderBindingTable, |
| const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pMissShaderBindingTable, |
| const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pHitShaderBindingTable, |
| const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pCallableShaderBindingTable, |
| uint32_t width, |
| uint32_t height, |
| uint32_t depth, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdTraceRaysKHR( m_commandBuffer, |
| reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( pRaygenShaderBindingTable ), |
| reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( pMissShaderBindingTable ), |
| reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( pHitShaderBindingTable ), |
| reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( pCallableShaderBindingTable ), |
| width, |
| height, |
| depth ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::traceRaysKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & raygenShaderBindingTable, |
| const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & missShaderBindingTable, |
| const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & hitShaderBindingTable, |
| const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & callableShaderBindingTable, |
| uint32_t width, |
| uint32_t height, |
| uint32_t depth, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdTraceRaysKHR && "Function <vkCmdTraceRaysKHR> requires <VK_KHR_ray_tracing_pipeline>" ); |
| # endif |
| |
| d.vkCmdTraceRaysKHR( m_commandBuffer, |
| reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &raygenShaderBindingTable ), |
| reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &missShaderBindingTable ), |
| reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &hitShaderBindingTable ), |
| reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &callableShaderBindingTable ), |
| width, |
| height, |
| depth ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| Device::createRayTracingPipelinesKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, |
| VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, |
| uint32_t createInfoCount, |
| const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR * pCreateInfos, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::Pipeline * pPipelines, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateRayTracingPipelinesKHR( m_device, |
| static_cast<VkDeferredOperationKHR>( deferredOperation ), |
| static_cast<VkPipelineCache>( pipelineCache ), |
| createInfoCount, |
| reinterpret_cast<const VkRayTracingPipelineCreateInfoKHR *>( pCreateInfos ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkPipeline *>( pPipelines ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename PipelineAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>> |
| Device::createRayTracingPipelinesKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, |
| VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateRayTracingPipelinesKHR && "Function <vkCreateRayTracingPipelinesKHR> requires <VK_KHR_ray_tracing_pipeline>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator> pipelines( createInfos.size() ); |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateRayTracingPipelinesKHR( |
| m_device, |
| static_cast<VkDeferredOperationKHR>( deferredOperation ), |
| static_cast<VkPipelineCache>( pipelineCache ), |
| createInfos.size(), |
| reinterpret_cast<const VkRayTracingPipelineCreateInfoKHR *>( createInfos.data() ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkPipeline *>( pipelines.data() ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesKHR", |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, |
| VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR, |
| VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR, |
| VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); |
| |
| return ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>( result, std::move( pipelines ) ); |
| } |
| |
| template <typename PipelineAllocator, |
| typename Dispatch, |
| typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, VULKAN_HPP_NAMESPACE::Pipeline>::value, int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>> |
| Device::createRayTracingPipelinesKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, |
| VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| PipelineAllocator & pipelineAllocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateRayTracingPipelinesKHR && "Function <vkCreateRayTracingPipelinesKHR> requires <VK_KHR_ray_tracing_pipeline>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator> pipelines( createInfos.size(), pipelineAllocator ); |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateRayTracingPipelinesKHR( |
| m_device, |
| static_cast<VkDeferredOperationKHR>( deferredOperation ), |
| static_cast<VkPipelineCache>( pipelineCache ), |
| createInfos.size(), |
| reinterpret_cast<const VkRayTracingPipelineCreateInfoKHR *>( createInfos.data() ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkPipeline *>( pipelines.data() ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesKHR", |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, |
| VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR, |
| VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR, |
| VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); |
| |
| return ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>( result, std::move( pipelines ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<VULKAN_HPP_NAMESPACE::Pipeline> |
| Device::createRayTracingPipelineKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, |
| VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, |
| const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateRayTracingPipelinesKHR && "Function <vkCreateRayTracingPipelinesKHR> requires <VK_KHR_ray_tracing_pipeline>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Pipeline pipeline; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateRayTracingPipelinesKHR( |
| m_device, |
| static_cast<VkDeferredOperationKHR>( deferredOperation ), |
| static_cast<VkPipelineCache>( pipelineCache ), |
| 1, |
| reinterpret_cast<const VkRayTracingPipelineCreateInfoKHR *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkPipeline *>( &pipeline ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelineKHR", |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, |
| VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR, |
| VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR, |
| VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); |
| |
| return ResultValue<VULKAN_HPP_NAMESPACE::Pipeline>( result, std::move( pipeline ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch, typename PipelineAllocator> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>> |
| Device::createRayTracingPipelinesKHRUnique( |
| VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, |
| VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateRayTracingPipelinesKHR && "Function <vkCreateRayTracingPipelinesKHR> requires <VK_KHR_ray_tracing_pipeline>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::Pipeline> pipelines( createInfos.size() ); |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateRayTracingPipelinesKHR( |
| m_device, |
| static_cast<VkDeferredOperationKHR>( deferredOperation ), |
| static_cast<VkPipelineCache>( pipelineCache ), |
| createInfos.size(), |
| reinterpret_cast<const VkRayTracingPipelineCreateInfoKHR *>( createInfos.data() ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkPipeline *>( pipelines.data() ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesKHRUnique", |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, |
| VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR, |
| VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR, |
| VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); |
| std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator> uniquePipelines; |
| uniquePipelines.reserve( createInfos.size() ); |
| ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d ); |
| for ( auto const & pipeline : pipelines ) |
| { |
| uniquePipelines.push_back( UniqueHandle<Pipeline, Dispatch>( pipeline, deleter ) ); |
| } |
| return ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>( result, std::move( uniquePipelines ) ); |
| } |
| |
| template < |
| typename Dispatch, |
| typename PipelineAllocator, |
| typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>::value, int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>> |
| Device::createRayTracingPipelinesKHRUnique( |
| VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, |
| VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| PipelineAllocator & pipelineAllocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateRayTracingPipelinesKHR && "Function <vkCreateRayTracingPipelinesKHR> requires <VK_KHR_ray_tracing_pipeline>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::Pipeline> pipelines( createInfos.size() ); |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateRayTracingPipelinesKHR( |
| m_device, |
| static_cast<VkDeferredOperationKHR>( deferredOperation ), |
| static_cast<VkPipelineCache>( pipelineCache ), |
| createInfos.size(), |
| reinterpret_cast<const VkRayTracingPipelineCreateInfoKHR *>( createInfos.data() ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkPipeline *>( pipelines.data() ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesKHRUnique", |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, |
| VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR, |
| VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR, |
| VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); |
| std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator> uniquePipelines( pipelineAllocator ); |
| uniquePipelines.reserve( createInfos.size() ); |
| ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d ); |
| for ( auto const & pipeline : pipelines ) |
| { |
| uniquePipelines.push_back( UniqueHandle<Pipeline, Dispatch>( pipeline, deleter ) ); |
| } |
| return ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>( result, std::move( uniquePipelines ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>> |
| Device::createRayTracingPipelineKHRUnique( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, |
| VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, |
| const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateRayTracingPipelinesKHR && "Function <vkCreateRayTracingPipelinesKHR> requires <VK_KHR_ray_tracing_pipeline>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Pipeline pipeline; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateRayTracingPipelinesKHR( |
| m_device, |
| static_cast<VkDeferredOperationKHR>( deferredOperation ), |
| static_cast<VkPipelineCache>( pipelineCache ), |
| 1, |
| reinterpret_cast<const VkRayTracingPipelineCreateInfoKHR *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkPipeline *>( &pipeline ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelineKHRUnique", |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, |
| VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR, |
| VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR, |
| VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); |
| |
| return ResultValue<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>( pipeline, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getRayTracingShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline, |
| uint32_t firstGroup, |
| uint32_t groupCount, |
| size_t dataSize, |
| void * pData, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( |
| d.vkGetRayTracingShaderGroupHandlesKHR( m_device, static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, dataSize, pData ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename DataType, typename DataTypeAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type Device::getRayTracingShaderGroupHandlesKHR( |
| VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetRayTracingShaderGroupHandlesKHR && |
| "Function <vkGetRayTracingShaderGroupHandlesKHR> requires <VK_KHR_ray_tracing_pipeline> or <VK_NV_ray_tracing>" ); |
| # endif |
| |
| VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 ); |
| std::vector<DataType, DataTypeAllocator> data( dataSize / sizeof( DataType ) ); |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetRayTracingShaderGroupHandlesKHR( |
| m_device, static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, data.size() * sizeof( DataType ), reinterpret_cast<void *>( data.data() ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandlesKHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); |
| } |
| |
| template <typename DataType, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<DataType>::type |
| Device::getRayTracingShaderGroupHandleKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetRayTracingShaderGroupHandlesKHR && |
| "Function <vkGetRayTracingShaderGroupHandlesKHR> requires <VK_KHR_ray_tracing_pipeline> or <VK_NV_ray_tracing>" ); |
| # endif |
| |
| DataType data; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetRayTracingShaderGroupHandlesKHR( |
| m_device, static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, sizeof( DataType ), reinterpret_cast<void *>( &data ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandleKHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getRayTracingCaptureReplayShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline, |
| uint32_t firstGroup, |
| uint32_t groupCount, |
| size_t dataSize, |
| void * pData, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( |
| d.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( m_device, static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, dataSize, pData ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename DataType, typename DataTypeAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type |
| Device::getRayTracingCaptureReplayShaderGroupHandlesKHR( |
| VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR && |
| "Function <vkGetRayTracingCaptureReplayShaderGroupHandlesKHR> requires <VK_KHR_ray_tracing_pipeline>" ); |
| # endif |
| |
| VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 ); |
| std::vector<DataType, DataTypeAllocator> data( dataSize / sizeof( DataType ) ); |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( |
| m_device, static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, data.size() * sizeof( DataType ), reinterpret_cast<void *>( data.data() ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingCaptureReplayShaderGroupHandlesKHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); |
| } |
| |
| template <typename DataType, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<DataType>::type Device::getRayTracingCaptureReplayShaderGroupHandleKHR( |
| VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR && |
| "Function <vkGetRayTracingCaptureReplayShaderGroupHandlesKHR> requires <VK_KHR_ray_tracing_pipeline>" ); |
| # endif |
| |
| DataType data; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( |
| m_device, static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, sizeof( DataType ), reinterpret_cast<void *>( &data ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingCaptureReplayShaderGroupHandleKHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::traceRaysIndirectKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pRaygenShaderBindingTable, |
| const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pMissShaderBindingTable, |
| const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pHitShaderBindingTable, |
| const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pCallableShaderBindingTable, |
| VULKAN_HPP_NAMESPACE::DeviceAddress indirectDeviceAddress, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdTraceRaysIndirectKHR( m_commandBuffer, |
| reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( pRaygenShaderBindingTable ), |
| reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( pMissShaderBindingTable ), |
| reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( pHitShaderBindingTable ), |
| reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( pCallableShaderBindingTable ), |
| static_cast<VkDeviceAddress>( indirectDeviceAddress ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::traceRaysIndirectKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & raygenShaderBindingTable, |
| const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & missShaderBindingTable, |
| const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & hitShaderBindingTable, |
| const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & callableShaderBindingTable, |
| VULKAN_HPP_NAMESPACE::DeviceAddress indirectDeviceAddress, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdTraceRaysIndirectKHR && "Function <vkCmdTraceRaysIndirectKHR> requires <VK_KHR_ray_tracing_pipeline>" ); |
| # endif |
| |
| d.vkCmdTraceRaysIndirectKHR( m_commandBuffer, |
| reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &raygenShaderBindingTable ), |
| reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &missShaderBindingTable ), |
| reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &hitShaderBindingTable ), |
| reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &callableShaderBindingTable ), |
| static_cast<VkDeviceAddress>( indirectDeviceAddress ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE DeviceSize Device::getRayTracingShaderGroupStackSizeKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline, |
| uint32_t group, |
| VULKAN_HPP_NAMESPACE::ShaderGroupShaderKHR groupShader, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<DeviceSize>( |
| d.vkGetRayTracingShaderGroupStackSizeKHR( m_device, static_cast<VkPipeline>( pipeline ), group, static_cast<VkShaderGroupShaderKHR>( groupShader ) ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setRayTracingPipelineStackSizeKHR( uint32_t pipelineStackSize, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetRayTracingPipelineStackSizeKHR( m_commandBuffer, pipelineStackSize ); |
| } |
| |
| //=== VK_KHR_sampler_ycbcr_conversion === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| Device::createSamplerYcbcrConversionKHR( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion * pYcbcrConversion, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateSamplerYcbcrConversionKHR( m_device, |
| reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkSamplerYcbcrConversion *>( pYcbcrConversion ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>::type |
| Device::createSamplerYcbcrConversionKHR( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateSamplerYcbcrConversionKHR && |
| "Function <vkCreateSamplerYcbcrConversionKHR> requires <VK_KHR_sampler_ycbcr_conversion> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateSamplerYcbcrConversionKHR( |
| m_device, |
| reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkSamplerYcbcrConversion *>( &ycbcrConversion ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSamplerYcbcrConversionKHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( ycbcrConversion ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion, Dispatch>>::type |
| Device::createSamplerYcbcrConversionKHRUnique( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateSamplerYcbcrConversionKHR && |
| "Function <vkCreateSamplerYcbcrConversionKHR> requires <VK_KHR_sampler_ycbcr_conversion> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateSamplerYcbcrConversionKHR( |
| m_device, |
| reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkSamplerYcbcrConversion *>( &ycbcrConversion ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSamplerYcbcrConversionKHRUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion, Dispatch>( ycbcrConversion, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroySamplerYcbcrConversionKHR( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroySamplerYcbcrConversionKHR( |
| m_device, static_cast<VkSamplerYcbcrConversion>( ycbcrConversion ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroySamplerYcbcrConversionKHR( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroySamplerYcbcrConversionKHR && |
| "Function <vkDestroySamplerYcbcrConversionKHR> requires <VK_KHR_sampler_ycbcr_conversion> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| d.vkDestroySamplerYcbcrConversionKHR( |
| m_device, |
| static_cast<VkSamplerYcbcrConversion>( ycbcrConversion ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_KHR_bind_memory2 === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::bindBufferMemory2KHR( uint32_t bindInfoCount, |
| const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo * pBindInfos, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkBindBufferMemory2KHR( m_device, bindInfoCount, reinterpret_cast<const VkBindBufferMemoryInfo *>( pBindInfos ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type |
| Device::bindBufferMemory2KHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const & bindInfos, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkBindBufferMemory2KHR && "Function <vkBindBufferMemory2KHR> requires <VK_KHR_bind_memory2> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkBindBufferMemory2KHR( m_device, bindInfos.size(), reinterpret_cast<const VkBindBufferMemoryInfo *>( bindInfos.data() ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindBufferMemory2KHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::bindImageMemory2KHR( uint32_t bindInfoCount, |
| const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo * pBindInfos, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkBindImageMemory2KHR( m_device, bindInfoCount, reinterpret_cast<const VkBindImageMemoryInfo *>( pBindInfos ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type |
| Device::bindImageMemory2KHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const & bindInfos, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkBindImageMemory2KHR && "Function <vkBindImageMemory2KHR> requires <VK_KHR_bind_memory2> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkBindImageMemory2KHR( m_device, bindInfos.size(), reinterpret_cast<const VkBindImageMemoryInfo *>( bindInfos.data() ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindImageMemory2KHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_EXT_image_drm_format_modifier === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getImageDrmFormatModifierPropertiesEXT( |
| VULKAN_HPP_NAMESPACE::Image image, VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT * pProperties, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetImageDrmFormatModifierPropertiesEXT( |
| m_device, static_cast<VkImage>( image ), reinterpret_cast<VkImageDrmFormatModifierPropertiesEXT *>( pProperties ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT>::type |
| Device::getImageDrmFormatModifierPropertiesEXT( VULKAN_HPP_NAMESPACE::Image image, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetImageDrmFormatModifierPropertiesEXT && |
| "Function <vkGetImageDrmFormatModifierPropertiesEXT> requires <VK_EXT_image_drm_format_modifier>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT properties; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetImageDrmFormatModifierPropertiesEXT( |
| m_device, static_cast<VkImage>( image ), reinterpret_cast<VkImageDrmFormatModifierPropertiesEXT *>( &properties ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getImageDrmFormatModifierPropertiesEXT" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_EXT_validation_cache === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createValidationCacheEXT( const VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::ValidationCacheEXT * pValidationCache, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateValidationCacheEXT( m_device, |
| reinterpret_cast<const VkValidationCacheCreateInfoEXT *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkValidationCacheEXT *>( pValidationCache ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::ValidationCacheEXT>::type |
| Device::createValidationCacheEXT( const VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateValidationCacheEXT && "Function <vkCreateValidationCacheEXT> requires <VK_EXT_validation_cache>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateValidationCacheEXT( |
| m_device, |
| reinterpret_cast<const VkValidationCacheCreateInfoEXT *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkValidationCacheEXT *>( &validationCache ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createValidationCacheEXT" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( validationCache ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ValidationCacheEXT, Dispatch>>::type |
| Device::createValidationCacheEXTUnique( const VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateValidationCacheEXT && "Function <vkCreateValidationCacheEXT> requires <VK_EXT_validation_cache>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateValidationCacheEXT( |
| m_device, |
| reinterpret_cast<const VkValidationCacheCreateInfoEXT *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkValidationCacheEXT *>( &validationCache ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createValidationCacheEXTUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::ValidationCacheEXT, Dispatch>( validationCache, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyValidationCacheEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyValidationCacheEXT( |
| m_device, static_cast<VkValidationCacheEXT>( validationCache ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyValidationCacheEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyValidationCacheEXT && "Function <vkDestroyValidationCacheEXT> requires <VK_EXT_validation_cache>" ); |
| # endif |
| |
| d.vkDestroyValidationCacheEXT( |
| m_device, |
| static_cast<VkValidationCacheEXT>( validationCache ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyValidationCacheEXT( |
| m_device, static_cast<VkValidationCacheEXT>( validationCache ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyValidationCacheEXT && "Function <vkDestroyValidationCacheEXT> requires <VK_EXT_validation_cache>" ); |
| # endif |
| |
| d.vkDestroyValidationCacheEXT( |
| m_device, |
| static_cast<VkValidationCacheEXT>( validationCache ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::mergeValidationCachesEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT dstCache, |
| uint32_t srcCacheCount, |
| const VULKAN_HPP_NAMESPACE::ValidationCacheEXT * pSrcCaches, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkMergeValidationCachesEXT( |
| m_device, static_cast<VkValidationCacheEXT>( dstCache ), srcCacheCount, reinterpret_cast<const VkValidationCacheEXT *>( pSrcCaches ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type |
| Device::mergeValidationCachesEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT dstCache, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ValidationCacheEXT> const & srcCaches, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkMergeValidationCachesEXT && "Function <vkMergeValidationCachesEXT> requires <VK_EXT_validation_cache>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkMergeValidationCachesEXT( |
| m_device, static_cast<VkValidationCacheEXT>( dstCache ), srcCaches.size(), reinterpret_cast<const VkValidationCacheEXT *>( srcCaches.data() ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::mergeValidationCachesEXT" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getValidationCacheDataEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache, |
| size_t * pDataSize, |
| void * pData, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetValidationCacheDataEXT( m_device, static_cast<VkValidationCacheEXT>( validationCache ), pDataSize, pData ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Uint8_tAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type |
| Device::getValidationCacheDataEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetValidationCacheDataEXT && "Function <vkGetValidationCacheDataEXT> requires <VK_EXT_validation_cache>" ); |
| # endif |
| |
| std::vector<uint8_t, Uint8_tAllocator> data; |
| size_t dataSize; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetValidationCacheDataEXT( m_device, static_cast<VkValidationCacheEXT>( validationCache ), &dataSize, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && dataSize ) |
| { |
| data.resize( dataSize ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetValidationCacheDataEXT( m_device, static_cast<VkValidationCacheEXT>( validationCache ), &dataSize, reinterpret_cast<void *>( data.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getValidationCacheDataEXT" ); |
| VULKAN_HPP_ASSERT( dataSize <= data.size() ); |
| if ( dataSize < data.size() ) |
| { |
| data.resize( dataSize ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); |
| } |
| |
| template <typename Uint8_tAllocator, |
| typename Dispatch, |
| typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type |
| Device::getValidationCacheDataEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache, Uint8_tAllocator & uint8_tAllocator, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetValidationCacheDataEXT && "Function <vkGetValidationCacheDataEXT> requires <VK_EXT_validation_cache>" ); |
| # endif |
| |
| std::vector<uint8_t, Uint8_tAllocator> data( uint8_tAllocator ); |
| size_t dataSize; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetValidationCacheDataEXT( m_device, static_cast<VkValidationCacheEXT>( validationCache ), &dataSize, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && dataSize ) |
| { |
| data.resize( dataSize ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetValidationCacheDataEXT( m_device, static_cast<VkValidationCacheEXT>( validationCache ), &dataSize, reinterpret_cast<void *>( data.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getValidationCacheDataEXT" ); |
| VULKAN_HPP_ASSERT( dataSize <= data.size() ); |
| if ( dataSize < data.size() ) |
| { |
| data.resize( dataSize ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_NV_shading_rate_image === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::bindShadingRateImageNV( VULKAN_HPP_NAMESPACE::ImageView imageView, |
| VULKAN_HPP_NAMESPACE::ImageLayout imageLayout, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdBindShadingRateImageNV( m_commandBuffer, static_cast<VkImageView>( imageView ), static_cast<VkImageLayout>( imageLayout ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setViewportShadingRatePaletteNV( uint32_t firstViewport, |
| uint32_t viewportCount, |
| const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV * pShadingRatePalettes, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetViewportShadingRatePaletteNV( |
| m_commandBuffer, firstViewport, viewportCount, reinterpret_cast<const VkShadingRatePaletteNV *>( pShadingRatePalettes ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setViewportShadingRatePaletteNV( |
| uint32_t firstViewport, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV> const & shadingRatePalettes, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdSetViewportShadingRatePaletteNV && "Function <vkCmdSetViewportShadingRatePaletteNV> requires <VK_NV_shading_rate_image>" ); |
| # endif |
| |
| d.vkCmdSetViewportShadingRatePaletteNV( |
| m_commandBuffer, firstViewport, shadingRatePalettes.size(), reinterpret_cast<const VkShadingRatePaletteNV *>( shadingRatePalettes.data() ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setCoarseSampleOrderNV( VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV sampleOrderType, |
| uint32_t customSampleOrderCount, |
| const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV * pCustomSampleOrders, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetCoarseSampleOrderNV( m_commandBuffer, |
| static_cast<VkCoarseSampleOrderTypeNV>( sampleOrderType ), |
| customSampleOrderCount, |
| reinterpret_cast<const VkCoarseSampleOrderCustomNV *>( pCustomSampleOrders ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void |
| CommandBuffer::setCoarseSampleOrderNV( VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV sampleOrderType, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV> const & customSampleOrders, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdSetCoarseSampleOrderNV && "Function <vkCmdSetCoarseSampleOrderNV> requires <VK_NV_shading_rate_image>" ); |
| # endif |
| |
| d.vkCmdSetCoarseSampleOrderNV( m_commandBuffer, |
| static_cast<VkCoarseSampleOrderTypeNV>( sampleOrderType ), |
| customSampleOrders.size(), |
| reinterpret_cast<const VkCoarseSampleOrderCustomNV *>( customSampleOrders.data() ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_NV_ray_tracing === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| Device::createAccelerationStructureNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::AccelerationStructureNV * pAccelerationStructure, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateAccelerationStructureNV( m_device, |
| reinterpret_cast<const VkAccelerationStructureCreateInfoNV *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkAccelerationStructureNV *>( pAccelerationStructure ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::AccelerationStructureNV>::type |
| Device::createAccelerationStructureNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateAccelerationStructureNV && "Function <vkCreateAccelerationStructureNV> requires <VK_NV_ray_tracing>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateAccelerationStructureNV( |
| m_device, |
| reinterpret_cast<const VkAccelerationStructureCreateInfoNV *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkAccelerationStructureNV *>( &accelerationStructure ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createAccelerationStructureNV" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( accelerationStructure ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::AccelerationStructureNV, Dispatch>>::type |
| Device::createAccelerationStructureNVUnique( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateAccelerationStructureNV && "Function <vkCreateAccelerationStructureNV> requires <VK_NV_ray_tracing>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateAccelerationStructureNV( |
| m_device, |
| reinterpret_cast<const VkAccelerationStructureCreateInfoNV *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkAccelerationStructureNV *>( &accelerationStructure ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createAccelerationStructureNVUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( |
| result, |
| UniqueHandle<VULKAN_HPP_NAMESPACE::AccelerationStructureNV, Dispatch>( accelerationStructure, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyAccelerationStructureNV( |
| m_device, static_cast<VkAccelerationStructureNV>( accelerationStructure ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyAccelerationStructureNV && "Function <vkDestroyAccelerationStructureNV> requires <VK_NV_ray_tracing>" ); |
| # endif |
| |
| d.vkDestroyAccelerationStructureNV( |
| m_device, |
| static_cast<VkAccelerationStructureNV>( accelerationStructure ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyAccelerationStructureNV( |
| m_device, static_cast<VkAccelerationStructureNV>( accelerationStructure ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyAccelerationStructureNV && "Function <vkDestroyAccelerationStructureNV> requires <VK_NV_ray_tracing>" ); |
| # endif |
| |
| d.vkDestroyAccelerationStructureNV( |
| m_device, |
| static_cast<VkAccelerationStructureNV>( accelerationStructure ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void |
| Device::getAccelerationStructureMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV * pInfo, |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR * pMemoryRequirements, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetAccelerationStructureMemoryRequirementsNV( m_device, |
| reinterpret_cast<const VkAccelerationStructureMemoryRequirementsInfoNV *>( pInfo ), |
| reinterpret_cast<VkMemoryRequirements2KHR *>( pMemoryRequirements ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR |
| Device::getAccelerationStructureMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV & info, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetAccelerationStructureMemoryRequirementsNV && |
| "Function <vkGetAccelerationStructureMemoryRequirementsNV> requires <VK_NV_ray_tracing>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR memoryRequirements; |
| d.vkGetAccelerationStructureMemoryRequirementsNV( m_device, |
| reinterpret_cast<const VkAccelerationStructureMemoryRequirementsInfoNV *>( &info ), |
| reinterpret_cast<VkMemoryRequirements2KHR *>( &memoryRequirements ) ); |
| |
| return memoryRequirements; |
| } |
| |
| template <typename X, typename Y, typename... Z, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> |
| Device::getAccelerationStructureMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV & info, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetAccelerationStructureMemoryRequirementsNV && |
| "Function <vkGetAccelerationStructureMemoryRequirementsNV> requires <VK_NV_ray_tracing>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain; |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR & memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR>(); |
| d.vkGetAccelerationStructureMemoryRequirementsNV( m_device, |
| reinterpret_cast<const VkAccelerationStructureMemoryRequirementsInfoNV *>( &info ), |
| reinterpret_cast<VkMemoryRequirements2KHR *>( &memoryRequirements ) ); |
| |
| return structureChain; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::bindAccelerationStructureMemoryNV( |
| uint32_t bindInfoCount, const VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV * pBindInfos, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( |
| d.vkBindAccelerationStructureMemoryNV( m_device, bindInfoCount, reinterpret_cast<const VkBindAccelerationStructureMemoryInfoNV *>( pBindInfos ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::bindAccelerationStructureMemoryNV( |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV> const & bindInfos, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkBindAccelerationStructureMemoryNV && "Function <vkBindAccelerationStructureMemoryNV> requires <VK_NV_ray_tracing>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkBindAccelerationStructureMemoryNV( |
| m_device, bindInfos.size(), reinterpret_cast<const VkBindAccelerationStructureMemoryInfoNV *>( bindInfos.data() ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindAccelerationStructureMemoryNV" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructureNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV * pInfo, |
| VULKAN_HPP_NAMESPACE::Buffer instanceData, |
| VULKAN_HPP_NAMESPACE::DeviceSize instanceOffset, |
| VULKAN_HPP_NAMESPACE::Bool32 update, |
| VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst, |
| VULKAN_HPP_NAMESPACE::AccelerationStructureNV src, |
| VULKAN_HPP_NAMESPACE::Buffer scratch, |
| VULKAN_HPP_NAMESPACE::DeviceSize scratchOffset, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdBuildAccelerationStructureNV( m_commandBuffer, |
| reinterpret_cast<const VkAccelerationStructureInfoNV *>( pInfo ), |
| static_cast<VkBuffer>( instanceData ), |
| static_cast<VkDeviceSize>( instanceOffset ), |
| static_cast<VkBool32>( update ), |
| static_cast<VkAccelerationStructureNV>( dst ), |
| static_cast<VkAccelerationStructureNV>( src ), |
| static_cast<VkBuffer>( scratch ), |
| static_cast<VkDeviceSize>( scratchOffset ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructureNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV & info, |
| VULKAN_HPP_NAMESPACE::Buffer instanceData, |
| VULKAN_HPP_NAMESPACE::DeviceSize instanceOffset, |
| VULKAN_HPP_NAMESPACE::Bool32 update, |
| VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst, |
| VULKAN_HPP_NAMESPACE::AccelerationStructureNV src, |
| VULKAN_HPP_NAMESPACE::Buffer scratch, |
| VULKAN_HPP_NAMESPACE::DeviceSize scratchOffset, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdBuildAccelerationStructureNV && "Function <vkCmdBuildAccelerationStructureNV> requires <VK_NV_ray_tracing>" ); |
| # endif |
| |
| d.vkCmdBuildAccelerationStructureNV( m_commandBuffer, |
| reinterpret_cast<const VkAccelerationStructureInfoNV *>( &info ), |
| static_cast<VkBuffer>( instanceData ), |
| static_cast<VkDeviceSize>( instanceOffset ), |
| static_cast<VkBool32>( update ), |
| static_cast<VkAccelerationStructureNV>( dst ), |
| static_cast<VkAccelerationStructureNV>( src ), |
| static_cast<VkBuffer>( scratch ), |
| static_cast<VkDeviceSize>( scratchOffset ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst, |
| VULKAN_HPP_NAMESPACE::AccelerationStructureNV src, |
| VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR mode, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdCopyAccelerationStructureNV( m_commandBuffer, |
| static_cast<VkAccelerationStructureNV>( dst ), |
| static_cast<VkAccelerationStructureNV>( src ), |
| static_cast<VkCopyAccelerationStructureModeKHR>( mode ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::traceRaysNV( VULKAN_HPP_NAMESPACE::Buffer raygenShaderBindingTableBuffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize raygenShaderBindingOffset, |
| VULKAN_HPP_NAMESPACE::Buffer missShaderBindingTableBuffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingOffset, |
| VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingStride, |
| VULKAN_HPP_NAMESPACE::Buffer hitShaderBindingTableBuffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingOffset, |
| VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingStride, |
| VULKAN_HPP_NAMESPACE::Buffer callableShaderBindingTableBuffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingOffset, |
| VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingStride, |
| uint32_t width, |
| uint32_t height, |
| uint32_t depth, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdTraceRaysNV( m_commandBuffer, |
| static_cast<VkBuffer>( raygenShaderBindingTableBuffer ), |
| static_cast<VkDeviceSize>( raygenShaderBindingOffset ), |
| static_cast<VkBuffer>( missShaderBindingTableBuffer ), |
| static_cast<VkDeviceSize>( missShaderBindingOffset ), |
| static_cast<VkDeviceSize>( missShaderBindingStride ), |
| static_cast<VkBuffer>( hitShaderBindingTableBuffer ), |
| static_cast<VkDeviceSize>( hitShaderBindingOffset ), |
| static_cast<VkDeviceSize>( hitShaderBindingStride ), |
| static_cast<VkBuffer>( callableShaderBindingTableBuffer ), |
| static_cast<VkDeviceSize>( callableShaderBindingOffset ), |
| static_cast<VkDeviceSize>( callableShaderBindingStride ), |
| width, |
| height, |
| depth ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createRayTracingPipelinesNV( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, |
| uint32_t createInfoCount, |
| const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV * pCreateInfos, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::Pipeline * pPipelines, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateRayTracingPipelinesNV( m_device, |
| static_cast<VkPipelineCache>( pipelineCache ), |
| createInfoCount, |
| reinterpret_cast<const VkRayTracingPipelineCreateInfoNV *>( pCreateInfos ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkPipeline *>( pPipelines ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename PipelineAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>> |
| Device::createRayTracingPipelinesNV( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateRayTracingPipelinesNV && "Function <vkCreateRayTracingPipelinesNV> requires <VK_NV_ray_tracing>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator> pipelines( createInfos.size() ); |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateRayTracingPipelinesNV( |
| m_device, |
| static_cast<VkPipelineCache>( pipelineCache ), |
| createInfos.size(), |
| reinterpret_cast<const VkRayTracingPipelineCreateInfoNV *>( createInfos.data() ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkPipeline *>( pipelines.data() ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesNV", |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); |
| |
| return ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>( result, std::move( pipelines ) ); |
| } |
| |
| template <typename PipelineAllocator, |
| typename Dispatch, |
| typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, VULKAN_HPP_NAMESPACE::Pipeline>::value, int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>> |
| Device::createRayTracingPipelinesNV( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| PipelineAllocator & pipelineAllocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateRayTracingPipelinesNV && "Function <vkCreateRayTracingPipelinesNV> requires <VK_NV_ray_tracing>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator> pipelines( createInfos.size(), pipelineAllocator ); |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateRayTracingPipelinesNV( |
| m_device, |
| static_cast<VkPipelineCache>( pipelineCache ), |
| createInfos.size(), |
| reinterpret_cast<const VkRayTracingPipelineCreateInfoNV *>( createInfos.data() ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkPipeline *>( pipelines.data() ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesNV", |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); |
| |
| return ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>( result, std::move( pipelines ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<VULKAN_HPP_NAMESPACE::Pipeline> |
| Device::createRayTracingPipelineNV( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, |
| const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateRayTracingPipelinesNV && "Function <vkCreateRayTracingPipelinesNV> requires <VK_NV_ray_tracing>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Pipeline pipeline; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateRayTracingPipelinesNV( |
| m_device, |
| static_cast<VkPipelineCache>( pipelineCache ), |
| 1, |
| reinterpret_cast<const VkRayTracingPipelineCreateInfoNV *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkPipeline *>( &pipeline ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelineNV", |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); |
| |
| return ResultValue<VULKAN_HPP_NAMESPACE::Pipeline>( result, std::move( pipeline ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch, typename PipelineAllocator> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>> |
| Device::createRayTracingPipelinesNVUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateRayTracingPipelinesNV && "Function <vkCreateRayTracingPipelinesNV> requires <VK_NV_ray_tracing>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::Pipeline> pipelines( createInfos.size() ); |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateRayTracingPipelinesNV( |
| m_device, |
| static_cast<VkPipelineCache>( pipelineCache ), |
| createInfos.size(), |
| reinterpret_cast<const VkRayTracingPipelineCreateInfoNV *>( createInfos.data() ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkPipeline *>( pipelines.data() ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesNVUnique", |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); |
| std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator> uniquePipelines; |
| uniquePipelines.reserve( createInfos.size() ); |
| ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d ); |
| for ( auto const & pipeline : pipelines ) |
| { |
| uniquePipelines.push_back( UniqueHandle<Pipeline, Dispatch>( pipeline, deleter ) ); |
| } |
| return ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>( result, std::move( uniquePipelines ) ); |
| } |
| |
| template < |
| typename Dispatch, |
| typename PipelineAllocator, |
| typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>::value, int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>> |
| Device::createRayTracingPipelinesNVUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| PipelineAllocator & pipelineAllocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateRayTracingPipelinesNV && "Function <vkCreateRayTracingPipelinesNV> requires <VK_NV_ray_tracing>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::Pipeline> pipelines( createInfos.size() ); |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateRayTracingPipelinesNV( |
| m_device, |
| static_cast<VkPipelineCache>( pipelineCache ), |
| createInfos.size(), |
| reinterpret_cast<const VkRayTracingPipelineCreateInfoNV *>( createInfos.data() ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkPipeline *>( pipelines.data() ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesNVUnique", |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); |
| std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator> uniquePipelines( pipelineAllocator ); |
| uniquePipelines.reserve( createInfos.size() ); |
| ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d ); |
| for ( auto const & pipeline : pipelines ) |
| { |
| uniquePipelines.push_back( UniqueHandle<Pipeline, Dispatch>( pipeline, deleter ) ); |
| } |
| return ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>( result, std::move( uniquePipelines ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>> |
| Device::createRayTracingPipelineNVUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, |
| const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateRayTracingPipelinesNV && "Function <vkCreateRayTracingPipelinesNV> requires <VK_NV_ray_tracing>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Pipeline pipeline; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateRayTracingPipelinesNV( |
| m_device, |
| static_cast<VkPipelineCache>( pipelineCache ), |
| 1, |
| reinterpret_cast<const VkRayTracingPipelineCreateInfoNV *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkPipeline *>( &pipeline ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelineNVUnique", |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); |
| |
| return ResultValue<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>( pipeline, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getRayTracingShaderGroupHandlesNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline, |
| uint32_t firstGroup, |
| uint32_t groupCount, |
| size_t dataSize, |
| void * pData, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( |
| d.vkGetRayTracingShaderGroupHandlesNV( m_device, static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, dataSize, pData ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename DataType, typename DataTypeAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type Device::getRayTracingShaderGroupHandlesNV( |
| VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetRayTracingShaderGroupHandlesNV && |
| "Function <vkGetRayTracingShaderGroupHandlesNV> requires <VK_KHR_ray_tracing_pipeline> or <VK_NV_ray_tracing>" ); |
| # endif |
| |
| VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 ); |
| std::vector<DataType, DataTypeAllocator> data( dataSize / sizeof( DataType ) ); |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetRayTracingShaderGroupHandlesNV( |
| m_device, static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, data.size() * sizeof( DataType ), reinterpret_cast<void *>( data.data() ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandlesNV" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); |
| } |
| |
| template <typename DataType, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<DataType>::type |
| Device::getRayTracingShaderGroupHandleNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetRayTracingShaderGroupHandlesNV && |
| "Function <vkGetRayTracingShaderGroupHandlesNV> requires <VK_KHR_ray_tracing_pipeline> or <VK_NV_ray_tracing>" ); |
| # endif |
| |
| DataType data; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetRayTracingShaderGroupHandlesNV( |
| m_device, static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, sizeof( DataType ), reinterpret_cast<void *>( &data ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandleNV" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure, |
| size_t dataSize, |
| void * pData, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( |
| d.vkGetAccelerationStructureHandleNV( m_device, static_cast<VkAccelerationStructureNV>( accelerationStructure ), dataSize, pData ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename DataType, typename DataTypeAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type |
| Device::getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure, size_t dataSize, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetAccelerationStructureHandleNV && "Function <vkGetAccelerationStructureHandleNV> requires <VK_NV_ray_tracing>" ); |
| # endif |
| |
| VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 ); |
| std::vector<DataType, DataTypeAllocator> data( dataSize / sizeof( DataType ) ); |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetAccelerationStructureHandleNV( |
| m_device, static_cast<VkAccelerationStructureNV>( accelerationStructure ), data.size() * sizeof( DataType ), reinterpret_cast<void *>( data.data() ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getAccelerationStructureHandleNV" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); |
| } |
| |
| template <typename DataType, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<DataType>::type |
| Device::getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetAccelerationStructureHandleNV && "Function <vkGetAccelerationStructureHandleNV> requires <VK_NV_ray_tracing>" ); |
| # endif |
| |
| DataType data; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetAccelerationStructureHandleNV( |
| m_device, static_cast<VkAccelerationStructureNV>( accelerationStructure ), sizeof( DataType ), reinterpret_cast<void *>( &data ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getAccelerationStructureHandleNV" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesNV( uint32_t accelerationStructureCount, |
| const VULKAN_HPP_NAMESPACE::AccelerationStructureNV * pAccelerationStructures, |
| VULKAN_HPP_NAMESPACE::QueryType queryType, |
| VULKAN_HPP_NAMESPACE::QueryPool queryPool, |
| uint32_t firstQuery, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdWriteAccelerationStructuresPropertiesNV( m_commandBuffer, |
| accelerationStructureCount, |
| reinterpret_cast<const VkAccelerationStructureNV *>( pAccelerationStructures ), |
| static_cast<VkQueryType>( queryType ), |
| static_cast<VkQueryPool>( queryPool ), |
| firstQuery ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesNV( |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureNV> const & accelerationStructures, |
| VULKAN_HPP_NAMESPACE::QueryType queryType, |
| VULKAN_HPP_NAMESPACE::QueryPool queryPool, |
| uint32_t firstQuery, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdWriteAccelerationStructuresPropertiesNV && |
| "Function <vkCmdWriteAccelerationStructuresPropertiesNV> requires <VK_NV_ray_tracing>" ); |
| # endif |
| |
| d.vkCmdWriteAccelerationStructuresPropertiesNV( m_commandBuffer, |
| accelerationStructures.size(), |
| reinterpret_cast<const VkAccelerationStructureNV *>( accelerationStructures.data() ), |
| static_cast<VkQueryType>( queryType ), |
| static_cast<VkQueryPool>( queryPool ), |
| firstQuery ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::compileDeferredNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline, |
| uint32_t shader, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCompileDeferredNV( m_device, static_cast<VkPipeline>( pipeline ), shader ) ); |
| } |
| #else |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type |
| Device::compileDeferredNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t shader, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCompileDeferredNV && "Function <vkCompileDeferredNV> requires <VK_NV_ray_tracing>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = |
| static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCompileDeferredNV( m_device, static_cast<VkPipeline>( pipeline ), shader ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::compileDeferredNV" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| //=== VK_KHR_maintenance3 === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::getDescriptorSetLayoutSupportKHR( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo * pCreateInfo, |
| VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport * pSupport, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetDescriptorSetLayoutSupportKHR( |
| m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( pCreateInfo ), reinterpret_cast<VkDescriptorSetLayoutSupport *>( pSupport ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport |
| Device::getDescriptorSetLayoutSupportKHR( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetDescriptorSetLayoutSupportKHR && |
| "Function <vkGetDescriptorSetLayoutSupportKHR> requires <VK_KHR_maintenance3> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport support; |
| d.vkGetDescriptorSetLayoutSupportKHR( |
| m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( &createInfo ), reinterpret_cast<VkDescriptorSetLayoutSupport *>( &support ) ); |
| |
| return support; |
| } |
| |
| template <typename X, typename Y, typename... Z, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> |
| Device::getDescriptorSetLayoutSupportKHR( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetDescriptorSetLayoutSupportKHR && |
| "Function <vkGetDescriptorSetLayoutSupportKHR> requires <VK_KHR_maintenance3> or <VK_VERSION_1_1>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain; |
| VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport & support = structureChain.template get<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport>(); |
| d.vkGetDescriptorSetLayoutSupportKHR( |
| m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( &createInfo ), reinterpret_cast<VkDescriptorSetLayoutSupport *>( &support ) ); |
| |
| return structureChain; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_KHR_draw_indirect_count === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer buffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize offset, |
| VULKAN_HPP_NAMESPACE::Buffer countBuffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, |
| uint32_t maxDrawCount, |
| uint32_t stride, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdDrawIndirectCountKHR( m_commandBuffer, |
| static_cast<VkBuffer>( buffer ), |
| static_cast<VkDeviceSize>( offset ), |
| static_cast<VkBuffer>( countBuffer ), |
| static_cast<VkDeviceSize>( countBufferOffset ), |
| maxDrawCount, |
| stride ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer buffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize offset, |
| VULKAN_HPP_NAMESPACE::Buffer countBuffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, |
| uint32_t maxDrawCount, |
| uint32_t stride, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdDrawIndexedIndirectCountKHR( m_commandBuffer, |
| static_cast<VkBuffer>( buffer ), |
| static_cast<VkDeviceSize>( offset ), |
| static_cast<VkBuffer>( countBuffer ), |
| static_cast<VkDeviceSize>( countBufferOffset ), |
| maxDrawCount, |
| stride ); |
| } |
| |
| //=== VK_EXT_external_memory_host === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| Device::getMemoryHostPointerPropertiesEXT( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, |
| const void * pHostPointer, |
| VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT * pMemoryHostPointerProperties, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetMemoryHostPointerPropertiesEXT( m_device, |
| static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ), |
| pHostPointer, |
| reinterpret_cast<VkMemoryHostPointerPropertiesEXT *>( pMemoryHostPointerProperties ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT>::type |
| Device::getMemoryHostPointerPropertiesEXT( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, |
| const void * pHostPointer, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetMemoryHostPointerPropertiesEXT && "Function <vkGetMemoryHostPointerPropertiesEXT> requires <VK_EXT_external_memory_host>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT memoryHostPointerProperties; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetMemoryHostPointerPropertiesEXT( m_device, |
| static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ), |
| pHostPointer, |
| reinterpret_cast<VkMemoryHostPointerPropertiesEXT *>( &memoryHostPointerProperties ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryHostPointerPropertiesEXT" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( memoryHostPointerProperties ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_AMD_buffer_marker === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::writeBufferMarkerAMD( VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage, |
| VULKAN_HPP_NAMESPACE::Buffer dstBuffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, |
| uint32_t marker, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdWriteBufferMarkerAMD( m_commandBuffer, |
| static_cast<VkPipelineStageFlagBits>( pipelineStage ), |
| static_cast<VkBuffer>( dstBuffer ), |
| static_cast<VkDeviceSize>( dstOffset ), |
| marker ); |
| } |
| |
| //=== VK_EXT_calibrated_timestamps === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getCalibrateableTimeDomainsEXT( uint32_t * pTimeDomainCount, |
| VULKAN_HPP_NAMESPACE::TimeDomainKHR * pTimeDomains, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( |
| d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( m_physicalDevice, pTimeDomainCount, reinterpret_cast<VkTimeDomainKHR *>( pTimeDomains ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename TimeDomainKHRAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR, TimeDomainKHRAllocator>>::type |
| PhysicalDevice::getCalibrateableTimeDomainsEXT( Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT && |
| "Function <vkGetPhysicalDeviceCalibrateableTimeDomainsEXT> requires <VK_EXT_calibrated_timestamps> or <VK_KHR_calibrated_timestamps>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR, TimeDomainKHRAllocator> timeDomains; |
| uint32_t timeDomainCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( m_physicalDevice, &timeDomainCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && timeDomainCount ) |
| { |
| timeDomains.resize( timeDomainCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( m_physicalDevice, &timeDomainCount, reinterpret_cast<VkTimeDomainKHR *>( timeDomains.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCalibrateableTimeDomainsEXT" ); |
| VULKAN_HPP_ASSERT( timeDomainCount <= timeDomains.size() ); |
| if ( timeDomainCount < timeDomains.size() ) |
| { |
| timeDomains.resize( timeDomainCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( timeDomains ) ); |
| } |
| |
| template <typename TimeDomainKHRAllocator, |
| typename Dispatch, |
| typename std::enable_if<std::is_same<typename TimeDomainKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::TimeDomainKHR>::value, int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR, TimeDomainKHRAllocator>>::type |
| PhysicalDevice::getCalibrateableTimeDomainsEXT( TimeDomainKHRAllocator & timeDomainKHRAllocator, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT && |
| "Function <vkGetPhysicalDeviceCalibrateableTimeDomainsEXT> requires <VK_EXT_calibrated_timestamps> or <VK_KHR_calibrated_timestamps>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR, TimeDomainKHRAllocator> timeDomains( timeDomainKHRAllocator ); |
| uint32_t timeDomainCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( m_physicalDevice, &timeDomainCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && timeDomainCount ) |
| { |
| timeDomains.resize( timeDomainCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( m_physicalDevice, &timeDomainCount, reinterpret_cast<VkTimeDomainKHR *>( timeDomains.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCalibrateableTimeDomainsEXT" ); |
| VULKAN_HPP_ASSERT( timeDomainCount <= timeDomains.size() ); |
| if ( timeDomainCount < timeDomains.size() ) |
| { |
| timeDomains.resize( timeDomainCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( timeDomains ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getCalibratedTimestampsEXT( uint32_t timestampCount, |
| const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR * pTimestampInfos, |
| uint64_t * pTimestamps, |
| uint64_t * pMaxDeviation, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetCalibratedTimestampsEXT( |
| m_device, timestampCount, reinterpret_cast<const VkCalibratedTimestampInfoKHR *>( pTimestampInfos ), pTimestamps, pMaxDeviation ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Uint64_tAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type |
| Device::getCalibratedTimestampsEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR> const & timestampInfos, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetCalibratedTimestampsEXT && |
| "Function <vkGetCalibratedTimestampsEXT> requires <VK_EXT_calibrated_timestamps> or <VK_KHR_calibrated_timestamps>" ); |
| # endif |
| |
| std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t> data_( |
| std::piecewise_construct, std::forward_as_tuple( timestampInfos.size() ), std::forward_as_tuple( 0 ) ); |
| std::vector<uint64_t, Uint64_tAllocator> & timestamps = data_.first; |
| uint64_t & maxDeviation = data_.second; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetCalibratedTimestampsEXT( |
| m_device, timestampInfos.size(), reinterpret_cast<const VkCalibratedTimestampInfoKHR *>( timestampInfos.data() ), timestamps.data(), &maxDeviation ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsEXT" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data_ ) ); |
| } |
| |
| template <typename Uint64_tAllocator, |
| typename Dispatch, |
| typename std::enable_if<std::is_same<typename Uint64_tAllocator::value_type, uint64_t>::value, int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type |
| Device::getCalibratedTimestampsEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR> const & timestampInfos, |
| Uint64_tAllocator & uint64_tAllocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetCalibratedTimestampsEXT && |
| "Function <vkGetCalibratedTimestampsEXT> requires <VK_EXT_calibrated_timestamps> or <VK_KHR_calibrated_timestamps>" ); |
| # endif |
| |
| std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t> data_( |
| std::piecewise_construct, std::forward_as_tuple( timestampInfos.size(), uint64_tAllocator ), std::forward_as_tuple( 0 ) ); |
| std::vector<uint64_t, Uint64_tAllocator> & timestamps = data_.first; |
| uint64_t & maxDeviation = data_.second; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetCalibratedTimestampsEXT( |
| m_device, timestampInfos.size(), reinterpret_cast<const VkCalibratedTimestampInfoKHR *>( timestampInfos.data() ), timestamps.data(), &maxDeviation ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsEXT" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data_ ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::pair<uint64_t, uint64_t>>::type |
| Device::getCalibratedTimestampEXT( const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR & timestampInfo, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetCalibratedTimestampsEXT && |
| "Function <vkGetCalibratedTimestampsEXT> requires <VK_EXT_calibrated_timestamps> or <VK_KHR_calibrated_timestamps>" ); |
| # endif |
| |
| std::pair<uint64_t, uint64_t> data_; |
| uint64_t & timestamp = data_.first; |
| uint64_t & maxDeviation = data_.second; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetCalibratedTimestampsEXT( m_device, 1, reinterpret_cast<const VkCalibratedTimestampInfoKHR *>( ×tampInfo ), ×tamp, &maxDeviation ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampEXT" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data_ ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_NV_mesh_shader === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksNV( uint32_t taskCount, uint32_t firstTask, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdDrawMeshTasksNV( m_commandBuffer, taskCount, firstTask ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectNV( VULKAN_HPP_NAMESPACE::Buffer buffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize offset, |
| uint32_t drawCount, |
| uint32_t stride, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdDrawMeshTasksIndirectNV( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), drawCount, stride ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectCountNV( VULKAN_HPP_NAMESPACE::Buffer buffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize offset, |
| VULKAN_HPP_NAMESPACE::Buffer countBuffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, |
| uint32_t maxDrawCount, |
| uint32_t stride, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdDrawMeshTasksIndirectCountNV( m_commandBuffer, |
| static_cast<VkBuffer>( buffer ), |
| static_cast<VkDeviceSize>( offset ), |
| static_cast<VkBuffer>( countBuffer ), |
| static_cast<VkDeviceSize>( countBufferOffset ), |
| maxDrawCount, |
| stride ); |
| } |
| |
| //=== VK_NV_scissor_exclusive === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setExclusiveScissorEnableNV( uint32_t firstExclusiveScissor, |
| uint32_t exclusiveScissorCount, |
| const VULKAN_HPP_NAMESPACE::Bool32 * pExclusiveScissorEnables, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetExclusiveScissorEnableNV( |
| m_commandBuffer, firstExclusiveScissor, exclusiveScissorCount, reinterpret_cast<const VkBool32 *>( pExclusiveScissorEnables ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void |
| CommandBuffer::setExclusiveScissorEnableNV( uint32_t firstExclusiveScissor, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & exclusiveScissorEnables, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdSetExclusiveScissorEnableNV && "Function <vkCmdSetExclusiveScissorEnableNV> requires <VK_NV_scissor_exclusive>" ); |
| # endif |
| |
| d.vkCmdSetExclusiveScissorEnableNV( |
| m_commandBuffer, firstExclusiveScissor, exclusiveScissorEnables.size(), reinterpret_cast<const VkBool32 *>( exclusiveScissorEnables.data() ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setExclusiveScissorNV( uint32_t firstExclusiveScissor, |
| uint32_t exclusiveScissorCount, |
| const VULKAN_HPP_NAMESPACE::Rect2D * pExclusiveScissors, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetExclusiveScissorNV( m_commandBuffer, firstExclusiveScissor, exclusiveScissorCount, reinterpret_cast<const VkRect2D *>( pExclusiveScissors ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setExclusiveScissorNV( uint32_t firstExclusiveScissor, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & exclusiveScissors, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdSetExclusiveScissorNV && "Function <vkCmdSetExclusiveScissorNV> requires <VK_NV_scissor_exclusive>" ); |
| # endif |
| |
| d.vkCmdSetExclusiveScissorNV( |
| m_commandBuffer, firstExclusiveScissor, exclusiveScissors.size(), reinterpret_cast<const VkRect2D *>( exclusiveScissors.data() ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_NV_device_diagnostic_checkpoints === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setCheckpointNV( const void * pCheckpointMarker, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetCheckpointNV( m_commandBuffer, pCheckpointMarker ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename CheckpointMarkerType, typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setCheckpointNV( CheckpointMarkerType const & checkpointMarker, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdSetCheckpointNV && "Function <vkCmdSetCheckpointNV> requires <VK_NV_device_diagnostic_checkpoints>" ); |
| # endif |
| |
| d.vkCmdSetCheckpointNV( m_commandBuffer, reinterpret_cast<const void *>( &checkpointMarker ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Queue::getCheckpointDataNV( uint32_t * pCheckpointDataCount, |
| VULKAN_HPP_NAMESPACE::CheckpointDataNV * pCheckpointData, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetQueueCheckpointDataNV( m_queue, pCheckpointDataCount, reinterpret_cast<VkCheckpointDataNV *>( pCheckpointData ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename CheckpointDataNVAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::CheckpointDataNV, CheckpointDataNVAllocator> |
| Queue::getCheckpointDataNV( Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetQueueCheckpointDataNV && "Function <vkGetQueueCheckpointDataNV> requires <VK_NV_device_diagnostic_checkpoints>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::CheckpointDataNV, CheckpointDataNVAllocator> checkpointData; |
| uint32_t checkpointDataCount; |
| d.vkGetQueueCheckpointDataNV( m_queue, &checkpointDataCount, nullptr ); |
| checkpointData.resize( checkpointDataCount ); |
| d.vkGetQueueCheckpointDataNV( m_queue, &checkpointDataCount, reinterpret_cast<VkCheckpointDataNV *>( checkpointData.data() ) ); |
| |
| VULKAN_HPP_ASSERT( checkpointDataCount <= checkpointData.size() ); |
| if ( checkpointDataCount < checkpointData.size() ) |
| { |
| checkpointData.resize( checkpointDataCount ); |
| } |
| return checkpointData; |
| } |
| |
| template <typename CheckpointDataNVAllocator, |
| typename Dispatch, |
| typename std::enable_if<std::is_same<typename CheckpointDataNVAllocator::value_type, VULKAN_HPP_NAMESPACE::CheckpointDataNV>::value, int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::CheckpointDataNV, CheckpointDataNVAllocator> |
| Queue::getCheckpointDataNV( CheckpointDataNVAllocator & checkpointDataNVAllocator, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetQueueCheckpointDataNV && "Function <vkGetQueueCheckpointDataNV> requires <VK_NV_device_diagnostic_checkpoints>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::CheckpointDataNV, CheckpointDataNVAllocator> checkpointData( checkpointDataNVAllocator ); |
| uint32_t checkpointDataCount; |
| d.vkGetQueueCheckpointDataNV( m_queue, &checkpointDataCount, nullptr ); |
| checkpointData.resize( checkpointDataCount ); |
| d.vkGetQueueCheckpointDataNV( m_queue, &checkpointDataCount, reinterpret_cast<VkCheckpointDataNV *>( checkpointData.data() ) ); |
| |
| VULKAN_HPP_ASSERT( checkpointDataCount <= checkpointData.size() ); |
| if ( checkpointDataCount < checkpointData.size() ) |
| { |
| checkpointData.resize( checkpointDataCount ); |
| } |
| return checkpointData; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_KHR_timeline_semaphore === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSemaphoreCounterValueKHR( VULKAN_HPP_NAMESPACE::Semaphore semaphore, |
| uint64_t * pValue, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetSemaphoreCounterValueKHR( m_device, static_cast<VkSemaphore>( semaphore ), pValue ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<uint64_t>::type |
| Device::getSemaphoreCounterValueKHR( VULKAN_HPP_NAMESPACE::Semaphore semaphore, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetSemaphoreCounterValueKHR && "Function <vkGetSemaphoreCounterValueKHR> requires <VK_KHR_timeline_semaphore> or <VK_VERSION_1_2>" ); |
| # endif |
| |
| uint64_t value; |
| VULKAN_HPP_NAMESPACE::Result result = |
| static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetSemaphoreCounterValueKHR( m_device, static_cast<VkSemaphore>( semaphore ), &value ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreCounterValueKHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( value ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::waitSemaphoresKHR( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo * pWaitInfo, |
| uint64_t timeout, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkWaitSemaphoresKHR( m_device, reinterpret_cast<const VkSemaphoreWaitInfo *>( pWaitInfo ), timeout ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result |
| Device::waitSemaphoresKHR( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo & waitInfo, uint64_t timeout, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkWaitSemaphoresKHR && "Function <vkWaitSemaphoresKHR> requires <VK_KHR_timeline_semaphore> or <VK_VERSION_1_2>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = |
| static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkWaitSemaphoresKHR( m_device, reinterpret_cast<const VkSemaphoreWaitInfo *>( &waitInfo ), timeout ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( |
| result, VULKAN_HPP_NAMESPACE_STRING "::Device::waitSemaphoresKHR", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eTimeout } ); |
| |
| return static_cast<VULKAN_HPP_NAMESPACE::Result>( result ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::signalSemaphoreKHR( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo * pSignalInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkSignalSemaphoreKHR( m_device, reinterpret_cast<const VkSemaphoreSignalInfo *>( pSignalInfo ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type |
| Device::signalSemaphoreKHR( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo & signalInfo, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkSignalSemaphoreKHR && "Function <vkSignalSemaphoreKHR> requires <VK_KHR_timeline_semaphore> or <VK_VERSION_1_2>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = |
| static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkSignalSemaphoreKHR( m_device, reinterpret_cast<const VkSemaphoreSignalInfo *>( &signalInfo ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::signalSemaphoreKHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_INTEL_performance_query === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::initializePerformanceApiINTEL( |
| const VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL * pInitializeInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( |
| d.vkInitializePerformanceApiINTEL( m_device, reinterpret_cast<const VkInitializePerformanceApiInfoINTEL *>( pInitializeInfo ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type |
| Device::initializePerformanceApiINTEL( const VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL & initializeInfo, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkInitializePerformanceApiINTEL && "Function <vkInitializePerformanceApiINTEL> requires <VK_INTEL_performance_query>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkInitializePerformanceApiINTEL( m_device, reinterpret_cast<const VkInitializePerformanceApiInfoINTEL *>( &initializeInfo ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::initializePerformanceApiINTEL" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::uninitializePerformanceApiINTEL( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkUninitializePerformanceApiINTEL( m_device ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result CommandBuffer::setPerformanceMarkerINTEL( const VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL * pMarkerInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCmdSetPerformanceMarkerINTEL( m_commandBuffer, reinterpret_cast<const VkPerformanceMarkerInfoINTEL *>( pMarkerInfo ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type |
| CommandBuffer::setPerformanceMarkerINTEL( const VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL & markerInfo, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdSetPerformanceMarkerINTEL && "Function <vkCmdSetPerformanceMarkerINTEL> requires <VK_INTEL_performance_query>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCmdSetPerformanceMarkerINTEL( m_commandBuffer, reinterpret_cast<const VkPerformanceMarkerInfoINTEL *>( &markerInfo ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::setPerformanceMarkerINTEL" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result CommandBuffer::setPerformanceStreamMarkerINTEL( |
| const VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL * pMarkerInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( |
| d.vkCmdSetPerformanceStreamMarkerINTEL( m_commandBuffer, reinterpret_cast<const VkPerformanceStreamMarkerInfoINTEL *>( pMarkerInfo ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type |
| CommandBuffer::setPerformanceStreamMarkerINTEL( const VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL & markerInfo, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdSetPerformanceStreamMarkerINTEL && "Function <vkCmdSetPerformanceStreamMarkerINTEL> requires <VK_INTEL_performance_query>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCmdSetPerformanceStreamMarkerINTEL( m_commandBuffer, reinterpret_cast<const VkPerformanceStreamMarkerInfoINTEL *>( &markerInfo ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::setPerformanceStreamMarkerINTEL" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result CommandBuffer::setPerformanceOverrideINTEL( |
| const VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL * pOverrideInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( |
| d.vkCmdSetPerformanceOverrideINTEL( m_commandBuffer, reinterpret_cast<const VkPerformanceOverrideInfoINTEL *>( pOverrideInfo ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type |
| CommandBuffer::setPerformanceOverrideINTEL( const VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL & overrideInfo, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdSetPerformanceOverrideINTEL && "Function <vkCmdSetPerformanceOverrideINTEL> requires <VK_INTEL_performance_query>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCmdSetPerformanceOverrideINTEL( m_commandBuffer, reinterpret_cast<const VkPerformanceOverrideInfoINTEL *>( &overrideInfo ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::setPerformanceOverrideINTEL" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| Device::acquirePerformanceConfigurationINTEL( const VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL * pAcquireInfo, |
| VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL * pConfiguration, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkAcquirePerformanceConfigurationINTEL( m_device, |
| reinterpret_cast<const VkPerformanceConfigurationAcquireInfoINTEL *>( pAcquireInfo ), |
| reinterpret_cast<VkPerformanceConfigurationINTEL *>( pConfiguration ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL>::type |
| Device::acquirePerformanceConfigurationINTEL( const VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL & acquireInfo, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkAcquirePerformanceConfigurationINTEL && "Function <vkAcquirePerformanceConfigurationINTEL> requires <VK_INTEL_performance_query>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkAcquirePerformanceConfigurationINTEL( m_device, |
| reinterpret_cast<const VkPerformanceConfigurationAcquireInfoINTEL *>( &acquireInfo ), |
| reinterpret_cast<VkPerformanceConfigurationINTEL *>( &configuration ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::acquirePerformanceConfigurationINTEL" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( configuration ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL, Dispatch>>::type |
| Device::acquirePerformanceConfigurationINTELUnique( const VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL & acquireInfo, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkAcquirePerformanceConfigurationINTEL && "Function <vkAcquirePerformanceConfigurationINTEL> requires <VK_INTEL_performance_query>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkAcquirePerformanceConfigurationINTEL( m_device, |
| reinterpret_cast<const VkPerformanceConfigurationAcquireInfoINTEL *>( &acquireInfo ), |
| reinterpret_cast<VkPerformanceConfigurationINTEL *>( &configuration ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::acquirePerformanceConfigurationINTELUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL, Dispatch>( configuration, ObjectRelease<Device, Dispatch>( *this, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::releasePerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkReleasePerformanceConfigurationINTEL( m_device, static_cast<VkPerformanceConfigurationINTEL>( configuration ) ) ); |
| } |
| #else |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type |
| Device::releasePerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkReleasePerformanceConfigurationINTEL && "Function <vkReleasePerformanceConfigurationINTEL> requires <VK_INTEL_performance_query>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkReleasePerformanceConfigurationINTEL( m_device, static_cast<VkPerformanceConfigurationINTEL>( configuration ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::releasePerformanceConfigurationINTEL" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::release( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkReleasePerformanceConfigurationINTEL( m_device, static_cast<VkPerformanceConfigurationINTEL>( configuration ) ) ); |
| } |
| #else |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type |
| Device::release( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkReleasePerformanceConfigurationINTEL && "Function <vkReleasePerformanceConfigurationINTEL> requires <VK_INTEL_performance_query>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkReleasePerformanceConfigurationINTEL( m_device, static_cast<VkPerformanceConfigurationINTEL>( configuration ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::release" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Queue::setPerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkQueueSetPerformanceConfigurationINTEL( m_queue, static_cast<VkPerformanceConfigurationINTEL>( configuration ) ) ); |
| } |
| #else |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type |
| Queue::setPerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkQueueSetPerformanceConfigurationINTEL && |
| "Function <vkQueueSetPerformanceConfigurationINTEL> requires <VK_INTEL_performance_query>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkQueueSetPerformanceConfigurationINTEL( m_queue, static_cast<VkPerformanceConfigurationINTEL>( configuration ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::setPerformanceConfigurationINTEL" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getPerformanceParameterINTEL( VULKAN_HPP_NAMESPACE::PerformanceParameterTypeINTEL parameter, |
| VULKAN_HPP_NAMESPACE::PerformanceValueINTEL * pValue, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetPerformanceParameterINTEL( |
| m_device, static_cast<VkPerformanceParameterTypeINTEL>( parameter ), reinterpret_cast<VkPerformanceValueINTEL *>( pValue ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::PerformanceValueINTEL>::type |
| Device::getPerformanceParameterINTEL( VULKAN_HPP_NAMESPACE::PerformanceParameterTypeINTEL parameter, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPerformanceParameterINTEL && "Function <vkGetPerformanceParameterINTEL> requires <VK_INTEL_performance_query>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::PerformanceValueINTEL value; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPerformanceParameterINTEL( |
| m_device, static_cast<VkPerformanceParameterTypeINTEL>( parameter ), reinterpret_cast<VkPerformanceValueINTEL *>( &value ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPerformanceParameterINTEL" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( value ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_AMD_display_native_hdr === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::setLocalDimmingAMD( VULKAN_HPP_NAMESPACE::SwapchainKHR swapChain, |
| VULKAN_HPP_NAMESPACE::Bool32 localDimmingEnable, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkSetLocalDimmingAMD( m_device, static_cast<VkSwapchainKHR>( swapChain ), static_cast<VkBool32>( localDimmingEnable ) ); |
| } |
| |
| #if defined( VK_USE_PLATFORM_FUCHSIA ) |
| //=== VK_FUCHSIA_imagepipe_surface === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| Instance::createImagePipeSurfaceFUCHSIA( const VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateImagePipeSurfaceFUCHSIA( m_instance, |
| reinterpret_cast<const VkImagePipeSurfaceCreateInfoFUCHSIA *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) ); |
| } |
| |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type |
| Instance::createImagePipeSurfaceFUCHSIA( const VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateImagePipeSurfaceFUCHSIA && "Function <vkCreateImagePipeSurfaceFUCHSIA> requires <VK_FUCHSIA_imagepipe_surface>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateImagePipeSurfaceFUCHSIA( |
| m_instance, |
| reinterpret_cast<const VkImagePipeSurfaceCreateInfoFUCHSIA *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkSurfaceKHR *>( &surface ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createImagePipeSurfaceFUCHSIA" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( surface ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type |
| Instance::createImagePipeSurfaceFUCHSIAUnique( const VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateImagePipeSurfaceFUCHSIA && "Function <vkCreateImagePipeSurfaceFUCHSIA> requires <VK_FUCHSIA_imagepipe_surface>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateImagePipeSurfaceFUCHSIA( |
| m_instance, |
| reinterpret_cast<const VkImagePipeSurfaceCreateInfoFUCHSIA *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkSurfaceKHR *>( &surface ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createImagePipeSurfaceFUCHSIAUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>( surface, ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| #endif /*VK_USE_PLATFORM_FUCHSIA*/ |
| |
| #if defined( VK_USE_PLATFORM_METAL_EXT ) |
| //=== VK_EXT_metal_surface === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createMetalSurfaceEXT( const VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateMetalSurfaceEXT( m_instance, |
| reinterpret_cast<const VkMetalSurfaceCreateInfoEXT *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) ); |
| } |
| |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type |
| Instance::createMetalSurfaceEXT( const VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateMetalSurfaceEXT && "Function <vkCreateMetalSurfaceEXT> requires <VK_EXT_metal_surface>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateMetalSurfaceEXT( m_instance, |
| reinterpret_cast<const VkMetalSurfaceCreateInfoEXT *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkSurfaceKHR *>( &surface ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createMetalSurfaceEXT" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( surface ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type |
| Instance::createMetalSurfaceEXTUnique( const VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateMetalSurfaceEXT && "Function <vkCreateMetalSurfaceEXT> requires <VK_EXT_metal_surface>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateMetalSurfaceEXT( m_instance, |
| reinterpret_cast<const VkMetalSurfaceCreateInfoEXT *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkSurfaceKHR *>( &surface ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createMetalSurfaceEXTUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>( surface, ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| #endif /*VK_USE_PLATFORM_METAL_EXT*/ |
| |
| //=== VK_KHR_fragment_shading_rate === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| PhysicalDevice::getFragmentShadingRatesKHR( uint32_t * pFragmentShadingRateCount, |
| VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR * pFragmentShadingRates, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetPhysicalDeviceFragmentShadingRatesKHR( |
| m_physicalDevice, pFragmentShadingRateCount, reinterpret_cast<VkPhysicalDeviceFragmentShadingRateKHR *>( pFragmentShadingRates ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename PhysicalDeviceFragmentShadingRateKHRAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE |
| typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR, PhysicalDeviceFragmentShadingRateKHRAllocator>>::type |
| PhysicalDevice::getFragmentShadingRatesKHR( Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceFragmentShadingRatesKHR && |
| "Function <vkGetPhysicalDeviceFragmentShadingRatesKHR> requires <VK_KHR_fragment_shading_rate>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR, PhysicalDeviceFragmentShadingRateKHRAllocator> fragmentShadingRates; |
| uint32_t fragmentShadingRateCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = |
| static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPhysicalDeviceFragmentShadingRatesKHR( m_physicalDevice, &fragmentShadingRateCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && fragmentShadingRateCount ) |
| { |
| fragmentShadingRates.resize( fragmentShadingRateCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPhysicalDeviceFragmentShadingRatesKHR( |
| m_physicalDevice, &fragmentShadingRateCount, reinterpret_cast<VkPhysicalDeviceFragmentShadingRateKHR *>( fragmentShadingRates.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getFragmentShadingRatesKHR" ); |
| VULKAN_HPP_ASSERT( fragmentShadingRateCount <= fragmentShadingRates.size() ); |
| if ( fragmentShadingRateCount < fragmentShadingRates.size() ) |
| { |
| fragmentShadingRates.resize( fragmentShadingRateCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( fragmentShadingRates ) ); |
| } |
| |
| template <typename PhysicalDeviceFragmentShadingRateKHRAllocator, |
| typename Dispatch, |
| typename std::enable_if<std::is_same<typename PhysicalDeviceFragmentShadingRateKHRAllocator::value_type, |
| VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR>::value, |
| int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE |
| typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR, PhysicalDeviceFragmentShadingRateKHRAllocator>>::type |
| PhysicalDevice::getFragmentShadingRatesKHR( PhysicalDeviceFragmentShadingRateKHRAllocator & physicalDeviceFragmentShadingRateKHRAllocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceFragmentShadingRatesKHR && |
| "Function <vkGetPhysicalDeviceFragmentShadingRatesKHR> requires <VK_KHR_fragment_shading_rate>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR, PhysicalDeviceFragmentShadingRateKHRAllocator> fragmentShadingRates( |
| physicalDeviceFragmentShadingRateKHRAllocator ); |
| uint32_t fragmentShadingRateCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = |
| static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPhysicalDeviceFragmentShadingRatesKHR( m_physicalDevice, &fragmentShadingRateCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && fragmentShadingRateCount ) |
| { |
| fragmentShadingRates.resize( fragmentShadingRateCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPhysicalDeviceFragmentShadingRatesKHR( |
| m_physicalDevice, &fragmentShadingRateCount, reinterpret_cast<VkPhysicalDeviceFragmentShadingRateKHR *>( fragmentShadingRates.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getFragmentShadingRatesKHR" ); |
| VULKAN_HPP_ASSERT( fragmentShadingRateCount <= fragmentShadingRates.size() ); |
| if ( fragmentShadingRateCount < fragmentShadingRates.size() ) |
| { |
| fragmentShadingRates.resize( fragmentShadingRateCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( fragmentShadingRates ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setFragmentShadingRateKHR( const VULKAN_HPP_NAMESPACE::Extent2D * pFragmentSize, |
| const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2], |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetFragmentShadingRateKHR( |
| m_commandBuffer, reinterpret_cast<const VkExtent2D *>( pFragmentSize ), reinterpret_cast<const VkFragmentShadingRateCombinerOpKHR *>( combinerOps ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setFragmentShadingRateKHR( const VULKAN_HPP_NAMESPACE::Extent2D & fragmentSize, |
| const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2], |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdSetFragmentShadingRateKHR && "Function <vkCmdSetFragmentShadingRateKHR> requires <VK_KHR_fragment_shading_rate>" ); |
| # endif |
| |
| d.vkCmdSetFragmentShadingRateKHR( |
| m_commandBuffer, reinterpret_cast<const VkExtent2D *>( &fragmentSize ), reinterpret_cast<const VkFragmentShadingRateCombinerOpKHR *>( combinerOps ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_KHR_dynamic_rendering_local_read === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setRenderingAttachmentLocationsKHR( const VULKAN_HPP_NAMESPACE::RenderingAttachmentLocationInfoKHR * pLocationInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetRenderingAttachmentLocationsKHR( m_commandBuffer, reinterpret_cast<const VkRenderingAttachmentLocationInfoKHR *>( pLocationInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setRenderingAttachmentLocationsKHR( const VULKAN_HPP_NAMESPACE::RenderingAttachmentLocationInfoKHR & locationInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdSetRenderingAttachmentLocationsKHR && |
| "Function <vkCmdSetRenderingAttachmentLocationsKHR> requires <VK_KHR_dynamic_rendering_local_read>" ); |
| # endif |
| |
| d.vkCmdSetRenderingAttachmentLocationsKHR( m_commandBuffer, reinterpret_cast<const VkRenderingAttachmentLocationInfoKHR *>( &locationInfo ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setRenderingInputAttachmentIndicesKHR( const VULKAN_HPP_NAMESPACE::RenderingInputAttachmentIndexInfoKHR * pLocationInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetRenderingInputAttachmentIndicesKHR( m_commandBuffer, reinterpret_cast<const VkRenderingInputAttachmentIndexInfoKHR *>( pLocationInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setRenderingInputAttachmentIndicesKHR( const VULKAN_HPP_NAMESPACE::RenderingInputAttachmentIndexInfoKHR & locationInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdSetRenderingInputAttachmentIndicesKHR && |
| "Function <vkCmdSetRenderingInputAttachmentIndicesKHR> requires <VK_KHR_dynamic_rendering_local_read>" ); |
| # endif |
| |
| d.vkCmdSetRenderingInputAttachmentIndicesKHR( m_commandBuffer, reinterpret_cast<const VkRenderingInputAttachmentIndexInfoKHR *>( &locationInfo ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_EXT_buffer_device_address === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddressEXT( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<DeviceAddress>( d.vkGetBufferDeviceAddressEXT( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo *>( pInfo ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceAddress Device::getBufferAddressEXT( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetBufferDeviceAddressEXT && |
| "Function <vkGetBufferDeviceAddressEXT> requires <VK_EXT_buffer_device_address> or <VK_KHR_buffer_device_address> or <VK_VERSION_1_2>" ); |
| # endif |
| |
| VkDeviceAddress result = d.vkGetBufferDeviceAddressEXT( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo *>( &info ) ); |
| |
| return static_cast<VULKAN_HPP_NAMESPACE::DeviceAddress>( result ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_EXT_tooling_info === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getToolPropertiesEXT( uint32_t * pToolCount, |
| VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties * pToolProperties, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( |
| d.vkGetPhysicalDeviceToolPropertiesEXT( m_physicalDevice, pToolCount, reinterpret_cast<VkPhysicalDeviceToolProperties *>( pToolProperties ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename PhysicalDeviceToolPropertiesAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE |
| typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator>>::type |
| PhysicalDevice::getToolPropertiesEXT( Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceToolPropertiesEXT && |
| "Function <vkGetPhysicalDeviceToolPropertiesEXT> requires <VK_EXT_tooling_info> or <VK_VERSION_1_3>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator> toolProperties; |
| uint32_t toolCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPhysicalDeviceToolPropertiesEXT( m_physicalDevice, &toolCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && toolCount ) |
| { |
| toolProperties.resize( toolCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetPhysicalDeviceToolPropertiesEXT( m_physicalDevice, &toolCount, reinterpret_cast<VkPhysicalDeviceToolProperties *>( toolProperties.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getToolPropertiesEXT" ); |
| VULKAN_HPP_ASSERT( toolCount <= toolProperties.size() ); |
| if ( toolCount < toolProperties.size() ) |
| { |
| toolProperties.resize( toolCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( toolProperties ) ); |
| } |
| |
| template < |
| typename PhysicalDeviceToolPropertiesAllocator, |
| typename Dispatch, |
| typename std::enable_if<std::is_same<typename PhysicalDeviceToolPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties>::value, |
| int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE |
| typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator>>::type |
| PhysicalDevice::getToolPropertiesEXT( PhysicalDeviceToolPropertiesAllocator & physicalDeviceToolPropertiesAllocator, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceToolPropertiesEXT && |
| "Function <vkGetPhysicalDeviceToolPropertiesEXT> requires <VK_EXT_tooling_info> or <VK_VERSION_1_3>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator> toolProperties( |
| physicalDeviceToolPropertiesAllocator ); |
| uint32_t toolCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPhysicalDeviceToolPropertiesEXT( m_physicalDevice, &toolCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && toolCount ) |
| { |
| toolProperties.resize( toolCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetPhysicalDeviceToolPropertiesEXT( m_physicalDevice, &toolCount, reinterpret_cast<VkPhysicalDeviceToolProperties *>( toolProperties.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getToolPropertiesEXT" ); |
| VULKAN_HPP_ASSERT( toolCount <= toolProperties.size() ); |
| if ( toolCount < toolProperties.size() ) |
| { |
| toolProperties.resize( toolCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( toolProperties ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_KHR_present_wait === |
| |
| #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::waitForPresentKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, |
| uint64_t presentId, |
| uint64_t timeout, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkWaitForPresentKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), presentId, timeout ) ); |
| } |
| #else |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result |
| Device::waitForPresentKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, uint64_t presentId, uint64_t timeout, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkWaitForPresentKHR && "Function <vkWaitForPresentKHR> requires <VK_KHR_present_wait>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = |
| static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkWaitForPresentKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), presentId, timeout ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( |
| result, |
| VULKAN_HPP_NAMESPACE_STRING "::Device::waitForPresentKHR", |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eTimeout, VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR } ); |
| |
| return static_cast<VULKAN_HPP_NAMESPACE::Result>( result ); |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| //=== VK_NV_cooperative_matrix === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getCooperativeMatrixPropertiesNV( |
| uint32_t * pPropertyCount, VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV * pProperties, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( |
| m_physicalDevice, pPropertyCount, reinterpret_cast<VkCooperativeMatrixPropertiesNV *>( pProperties ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename CooperativeMatrixPropertiesNVAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE |
| typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV, CooperativeMatrixPropertiesNVAllocator>>::type |
| PhysicalDevice::getCooperativeMatrixPropertiesNV( Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV && |
| "Function <vkGetPhysicalDeviceCooperativeMatrixPropertiesNV> requires <VK_NV_cooperative_matrix>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV, CooperativeMatrixPropertiesNVAllocator> properties; |
| uint32_t propertyCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( m_physicalDevice, &propertyCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount ) |
| { |
| properties.resize( propertyCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( |
| m_physicalDevice, &propertyCount, reinterpret_cast<VkCooperativeMatrixPropertiesNV *>( properties.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCooperativeMatrixPropertiesNV" ); |
| VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); |
| if ( propertyCount < properties.size() ) |
| { |
| properties.resize( propertyCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); |
| } |
| |
| template <typename CooperativeMatrixPropertiesNVAllocator, |
| typename Dispatch, |
| typename std::enable_if< |
| std::is_same<typename CooperativeMatrixPropertiesNVAllocator::value_type, VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV>::value, |
| int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE |
| typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV, CooperativeMatrixPropertiesNVAllocator>>::type |
| PhysicalDevice::getCooperativeMatrixPropertiesNV( CooperativeMatrixPropertiesNVAllocator & cooperativeMatrixPropertiesNVAllocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV && |
| "Function <vkGetPhysicalDeviceCooperativeMatrixPropertiesNV> requires <VK_NV_cooperative_matrix>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV, CooperativeMatrixPropertiesNVAllocator> properties( |
| cooperativeMatrixPropertiesNVAllocator ); |
| uint32_t propertyCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( m_physicalDevice, &propertyCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount ) |
| { |
| properties.resize( propertyCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( |
| m_physicalDevice, &propertyCount, reinterpret_cast<VkCooperativeMatrixPropertiesNV *>( properties.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCooperativeMatrixPropertiesNV" ); |
| VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); |
| if ( propertyCount < properties.size() ) |
| { |
| properties.resize( propertyCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_NV_coverage_reduction_mode === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV( |
| uint32_t * pCombinationCount, VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV * pCombinations, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( |
| m_physicalDevice, pCombinationCount, reinterpret_cast<VkFramebufferMixedSamplesCombinationNV *>( pCombinations ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename FramebufferMixedSamplesCombinationNVAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE |
| typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV, FramebufferMixedSamplesCombinationNVAllocator>>::type |
| PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV( Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV && |
| "Function <vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV> requires <VK_NV_coverage_reduction_mode>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV, FramebufferMixedSamplesCombinationNVAllocator> combinations; |
| uint32_t combinationCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( m_physicalDevice, &combinationCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && combinationCount ) |
| { |
| combinations.resize( combinationCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( |
| m_physicalDevice, &combinationCount, reinterpret_cast<VkFramebufferMixedSamplesCombinationNV *>( combinations.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV" ); |
| VULKAN_HPP_ASSERT( combinationCount <= combinations.size() ); |
| if ( combinationCount < combinations.size() ) |
| { |
| combinations.resize( combinationCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( combinations ) ); |
| } |
| |
| template <typename FramebufferMixedSamplesCombinationNVAllocator, |
| typename Dispatch, |
| typename std::enable_if<std::is_same<typename FramebufferMixedSamplesCombinationNVAllocator::value_type, |
| VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV>::value, |
| int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE |
| typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV, FramebufferMixedSamplesCombinationNVAllocator>>::type |
| PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV( |
| FramebufferMixedSamplesCombinationNVAllocator & framebufferMixedSamplesCombinationNVAllocator, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV && |
| "Function <vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV> requires <VK_NV_coverage_reduction_mode>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV, FramebufferMixedSamplesCombinationNVAllocator> combinations( |
| framebufferMixedSamplesCombinationNVAllocator ); |
| uint32_t combinationCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( m_physicalDevice, &combinationCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && combinationCount ) |
| { |
| combinations.resize( combinationCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( |
| m_physicalDevice, &combinationCount, reinterpret_cast<VkFramebufferMixedSamplesCombinationNV *>( combinations.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV" ); |
| VULKAN_HPP_ASSERT( combinationCount <= combinations.size() ); |
| if ( combinationCount < combinations.size() ) |
| { |
| combinations.resize( combinationCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( combinations ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| #if defined( VK_USE_PLATFORM_WIN32_KHR ) |
| //=== VK_EXT_full_screen_exclusive === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| PhysicalDevice::getSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo, |
| uint32_t * pPresentModeCount, |
| VULKAN_HPP_NAMESPACE::PresentModeKHR * pPresentModes, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetPhysicalDeviceSurfacePresentModes2EXT( m_physicalDevice, |
| reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( pSurfaceInfo ), |
| pPresentModeCount, |
| reinterpret_cast<VkPresentModeKHR *>( pPresentModes ) ) ); |
| } |
| |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename PresentModeKHRAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR, PresentModeKHRAllocator>>::type |
| PhysicalDevice::getSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfacePresentModes2EXT && |
| "Function <vkGetPhysicalDeviceSurfacePresentModes2EXT> requires <VK_EXT_full_screen_exclusive>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR, PresentModeKHRAllocator> presentModes; |
| uint32_t presentModeCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPhysicalDeviceSurfacePresentModes2EXT( |
| m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ), &presentModeCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && presentModeCount ) |
| { |
| presentModes.resize( presentModeCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetPhysicalDeviceSurfacePresentModes2EXT( m_physicalDevice, |
| reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ), |
| &presentModeCount, |
| reinterpret_cast<VkPresentModeKHR *>( presentModes.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfacePresentModes2EXT" ); |
| VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() ); |
| if ( presentModeCount < presentModes.size() ) |
| { |
| presentModes.resize( presentModeCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( presentModes ) ); |
| } |
| |
| template <typename PresentModeKHRAllocator, |
| typename Dispatch, |
| typename std::enable_if<std::is_same<typename PresentModeKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::PresentModeKHR>::value, int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR, PresentModeKHRAllocator>>::type |
| PhysicalDevice::getSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, |
| PresentModeKHRAllocator & presentModeKHRAllocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfacePresentModes2EXT && |
| "Function <vkGetPhysicalDeviceSurfacePresentModes2EXT> requires <VK_EXT_full_screen_exclusive>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR, PresentModeKHRAllocator> presentModes( presentModeKHRAllocator ); |
| uint32_t presentModeCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPhysicalDeviceSurfacePresentModes2EXT( |
| m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ), &presentModeCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && presentModeCount ) |
| { |
| presentModes.resize( presentModeCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetPhysicalDeviceSurfacePresentModes2EXT( m_physicalDevice, |
| reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ), |
| &presentModeCount, |
| reinterpret_cast<VkPresentModeKHR *>( presentModes.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfacePresentModes2EXT" ); |
| VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() ); |
| if ( presentModeCount < presentModes.size() ) |
| { |
| presentModes.resize( presentModeCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( presentModes ) ); |
| } |
| # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| # ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::acquireFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkAcquireFullScreenExclusiveModeEXT( m_device, static_cast<VkSwapchainKHR>( swapchain ) ) ); |
| } |
| # else |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type |
| Device::acquireFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkAcquireFullScreenExclusiveModeEXT && "Function <vkAcquireFullScreenExclusiveModeEXT> requires <VK_EXT_full_screen_exclusive>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = |
| static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkAcquireFullScreenExclusiveModeEXT( m_device, static_cast<VkSwapchainKHR>( swapchain ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::acquireFullScreenExclusiveModeEXT" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); |
| } |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| # ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::releaseFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkReleaseFullScreenExclusiveModeEXT( m_device, static_cast<VkSwapchainKHR>( swapchain ) ) ); |
| } |
| # else |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type |
| Device::releaseFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkReleaseFullScreenExclusiveModeEXT && "Function <vkReleaseFullScreenExclusiveModeEXT> requires <VK_EXT_full_screen_exclusive>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = |
| static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkReleaseFullScreenExclusiveModeEXT( m_device, static_cast<VkSwapchainKHR>( swapchain ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::releaseFullScreenExclusiveModeEXT" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); |
| } |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| Device::getGroupSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo, |
| VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR * pModes, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetDeviceGroupSurfacePresentModes2EXT( |
| m_device, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( pSurfaceInfo ), reinterpret_cast<VkDeviceGroupPresentModeFlagsKHR *>( pModes ) ) ); |
| } |
| |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR>::type |
| Device::getGroupSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetDeviceGroupSurfacePresentModes2EXT && |
| "Function <vkGetDeviceGroupSurfacePresentModes2EXT> requires <VK_EXT_full_screen_exclusive>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR modes; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetDeviceGroupSurfacePresentModes2EXT( |
| m_device, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ), reinterpret_cast<VkDeviceGroupPresentModeFlagsKHR *>( &modes ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getGroupSurfacePresentModes2EXT" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( modes ) ); |
| } |
| # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| #endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| //=== VK_EXT_headless_surface === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createHeadlessSurfaceEXT( const VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateHeadlessSurfaceEXT( m_instance, |
| reinterpret_cast<const VkHeadlessSurfaceCreateInfoEXT *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type |
| Instance::createHeadlessSurfaceEXT( const VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateHeadlessSurfaceEXT && "Function <vkCreateHeadlessSurfaceEXT> requires <VK_EXT_headless_surface>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateHeadlessSurfaceEXT( |
| m_instance, |
| reinterpret_cast<const VkHeadlessSurfaceCreateInfoEXT *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkSurfaceKHR *>( &surface ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createHeadlessSurfaceEXT" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( surface ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type |
| Instance::createHeadlessSurfaceEXTUnique( const VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateHeadlessSurfaceEXT && "Function <vkCreateHeadlessSurfaceEXT> requires <VK_EXT_headless_surface>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateHeadlessSurfaceEXT( |
| m_instance, |
| reinterpret_cast<const VkHeadlessSurfaceCreateInfoEXT *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkSurfaceKHR *>( &surface ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createHeadlessSurfaceEXTUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>( surface, ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_KHR_buffer_device_address === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<DeviceAddress>( d.vkGetBufferDeviceAddressKHR( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo *>( pInfo ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceAddress Device::getBufferAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetBufferDeviceAddressKHR && |
| "Function <vkGetBufferDeviceAddressKHR> requires <VK_EXT_buffer_device_address> or <VK_KHR_buffer_device_address> or <VK_VERSION_1_2>" ); |
| # endif |
| |
| VkDeviceAddress result = d.vkGetBufferDeviceAddressKHR( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo *>( &info ) ); |
| |
| return static_cast<VULKAN_HPP_NAMESPACE::DeviceAddress>( result ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE uint64_t Device::getBufferOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return d.vkGetBufferOpaqueCaptureAddressKHR( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo *>( pInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE uint64_t Device::getBufferOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetBufferOpaqueCaptureAddressKHR && |
| "Function <vkGetBufferOpaqueCaptureAddressKHR> requires <VK_KHR_buffer_device_address> or <VK_VERSION_1_2>" ); |
| # endif |
| |
| uint64_t result = d.vkGetBufferOpaqueCaptureAddressKHR( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo *>( &info ) ); |
| |
| return result; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE uint64_t Device::getMemoryOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo * pInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return d.vkGetDeviceMemoryOpaqueCaptureAddressKHR( m_device, reinterpret_cast<const VkDeviceMemoryOpaqueCaptureAddressInfo *>( pInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE uint64_t Device::getMemoryOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo & info, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetDeviceMemoryOpaqueCaptureAddressKHR && |
| "Function <vkGetDeviceMemoryOpaqueCaptureAddressKHR> requires <VK_KHR_buffer_device_address> or <VK_VERSION_1_2>" ); |
| # endif |
| |
| uint64_t result = d.vkGetDeviceMemoryOpaqueCaptureAddressKHR( m_device, reinterpret_cast<const VkDeviceMemoryOpaqueCaptureAddressInfo *>( &info ) ); |
| |
| return result; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_EXT_line_rasterization === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void |
| CommandBuffer::setLineStippleEXT( uint32_t lineStippleFactor, uint16_t lineStipplePattern, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetLineStippleEXT( m_commandBuffer, lineStippleFactor, lineStipplePattern ); |
| } |
| |
| //=== VK_EXT_host_query_reset === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::resetQueryPoolEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool, |
| uint32_t firstQuery, |
| uint32_t queryCount, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkResetQueryPoolEXT( m_device, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount ); |
| } |
| |
| //=== VK_EXT_extended_dynamic_state === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setCullModeEXT( VULKAN_HPP_NAMESPACE::CullModeFlags cullMode, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetCullModeEXT( m_commandBuffer, static_cast<VkCullModeFlags>( cullMode ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setFrontFaceEXT( VULKAN_HPP_NAMESPACE::FrontFace frontFace, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetFrontFaceEXT( m_commandBuffer, static_cast<VkFrontFace>( frontFace ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setPrimitiveTopologyEXT( VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetPrimitiveTopologyEXT( m_commandBuffer, static_cast<VkPrimitiveTopology>( primitiveTopology ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setViewportWithCountEXT( uint32_t viewportCount, |
| const VULKAN_HPP_NAMESPACE::Viewport * pViewports, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetViewportWithCountEXT( m_commandBuffer, viewportCount, reinterpret_cast<const VkViewport *>( pViewports ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setViewportWithCountEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdSetViewportWithCountEXT && |
| "Function <vkCmdSetViewportWithCountEXT> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" ); |
| # endif |
| |
| d.vkCmdSetViewportWithCountEXT( m_commandBuffer, viewports.size(), reinterpret_cast<const VkViewport *>( viewports.data() ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void |
| CommandBuffer::setScissorWithCountEXT( uint32_t scissorCount, const VULKAN_HPP_NAMESPACE::Rect2D * pScissors, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetScissorWithCountEXT( m_commandBuffer, scissorCount, reinterpret_cast<const VkRect2D *>( pScissors ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setScissorWithCountEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdSetScissorWithCountEXT && |
| "Function <vkCmdSetScissorWithCountEXT> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" ); |
| # endif |
| |
| d.vkCmdSetScissorWithCountEXT( m_commandBuffer, scissors.size(), reinterpret_cast<const VkRect2D *>( scissors.data() ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers2EXT( uint32_t firstBinding, |
| uint32_t bindingCount, |
| const VULKAN_HPP_NAMESPACE::Buffer * pBuffers, |
| const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets, |
| const VULKAN_HPP_NAMESPACE::DeviceSize * pSizes, |
| const VULKAN_HPP_NAMESPACE::DeviceSize * pStrides, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdBindVertexBuffers2EXT( m_commandBuffer, |
| firstBinding, |
| bindingCount, |
| reinterpret_cast<const VkBuffer *>( pBuffers ), |
| reinterpret_cast<const VkDeviceSize *>( pOffsets ), |
| reinterpret_cast<const VkDeviceSize *>( pSizes ), |
| reinterpret_cast<const VkDeviceSize *>( pStrides ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers2EXT( uint32_t firstBinding, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & strides, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdBindVertexBuffers2EXT && |
| "Function <vkCmdBindVertexBuffers2EXT> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" ); |
| # endif |
| # ifdef VULKAN_HPP_NO_EXCEPTIONS |
| VULKAN_HPP_ASSERT( buffers.size() == offsets.size() ); |
| VULKAN_HPP_ASSERT( sizes.empty() || buffers.size() == sizes.size() ); |
| VULKAN_HPP_ASSERT( strides.empty() || buffers.size() == strides.size() ); |
| # else |
| if ( buffers.size() != offsets.size() ) |
| { |
| throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers2EXT: buffers.size() != offsets.size()" ); |
| } |
| if ( !sizes.empty() && buffers.size() != sizes.size() ) |
| { |
| throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers2EXT: buffers.size() != sizes.size()" ); |
| } |
| if ( !strides.empty() && buffers.size() != strides.size() ) |
| { |
| throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers2EXT: buffers.size() != strides.size()" ); |
| } |
| # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ |
| |
| d.vkCmdBindVertexBuffers2EXT( m_commandBuffer, |
| firstBinding, |
| buffers.size(), |
| reinterpret_cast<const VkBuffer *>( buffers.data() ), |
| reinterpret_cast<const VkDeviceSize *>( offsets.data() ), |
| reinterpret_cast<const VkDeviceSize *>( sizes.data() ), |
| reinterpret_cast<const VkDeviceSize *>( strides.data() ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setDepthTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetDepthTestEnableEXT( m_commandBuffer, static_cast<VkBool32>( depthTestEnable ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setDepthWriteEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetDepthWriteEnableEXT( m_commandBuffer, static_cast<VkBool32>( depthWriteEnable ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setDepthCompareOpEXT( VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetDepthCompareOpEXT( m_commandBuffer, static_cast<VkCompareOp>( depthCompareOp ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setDepthBoundsTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetDepthBoundsTestEnableEXT( m_commandBuffer, static_cast<VkBool32>( depthBoundsTestEnable ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setStencilTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetStencilTestEnableEXT( m_commandBuffer, static_cast<VkBool32>( stencilTestEnable ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setStencilOpEXT( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, |
| VULKAN_HPP_NAMESPACE::StencilOp failOp, |
| VULKAN_HPP_NAMESPACE::StencilOp passOp, |
| VULKAN_HPP_NAMESPACE::StencilOp depthFailOp, |
| VULKAN_HPP_NAMESPACE::CompareOp compareOp, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetStencilOpEXT( m_commandBuffer, |
| static_cast<VkStencilFaceFlags>( faceMask ), |
| static_cast<VkStencilOp>( failOp ), |
| static_cast<VkStencilOp>( passOp ), |
| static_cast<VkStencilOp>( depthFailOp ), |
| static_cast<VkCompareOp>( compareOp ) ); |
| } |
| |
| //=== VK_KHR_deferred_host_operations === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createDeferredOperationKHR( const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::DeferredOperationKHR * pDeferredOperation, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateDeferredOperationKHR( |
| m_device, reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), reinterpret_cast<VkDeferredOperationKHR *>( pDeferredOperation ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::DeferredOperationKHR>::type |
| Device::createDeferredOperationKHR( Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateDeferredOperationKHR && "Function <vkCreateDeferredOperationKHR> requires <VK_KHR_deferred_host_operations>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateDeferredOperationKHR( |
| m_device, |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkDeferredOperationKHR *>( &deferredOperation ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDeferredOperationKHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( deferredOperation ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DeferredOperationKHR, Dispatch>>::type |
| Device::createDeferredOperationKHRUnique( Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateDeferredOperationKHR && "Function <vkCreateDeferredOperationKHR> requires <VK_KHR_deferred_host_operations>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateDeferredOperationKHR( |
| m_device, |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkDeferredOperationKHR *>( &deferredOperation ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDeferredOperationKHRUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::DeferredOperationKHR, Dispatch>( deferredOperation, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyDeferredOperationKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyDeferredOperationKHR( |
| m_device, static_cast<VkDeferredOperationKHR>( operation ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyDeferredOperationKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyDeferredOperationKHR && "Function <vkDestroyDeferredOperationKHR> requires <VK_KHR_deferred_host_operations>" ); |
| # endif |
| |
| d.vkDestroyDeferredOperationKHR( |
| m_device, |
| static_cast<VkDeferredOperationKHR>( operation ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyDeferredOperationKHR( |
| m_device, static_cast<VkDeferredOperationKHR>( operation ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyDeferredOperationKHR && "Function <vkDestroyDeferredOperationKHR> requires <VK_KHR_deferred_host_operations>" ); |
| # endif |
| |
| d.vkDestroyDeferredOperationKHR( |
| m_device, |
| static_cast<VkDeferredOperationKHR>( operation ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE uint32_t Device::getDeferredOperationMaxConcurrencyKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return d.vkGetDeferredOperationMaxConcurrencyKHR( m_device, static_cast<VkDeferredOperationKHR>( operation ) ); |
| } |
| |
| #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getDeferredOperationResultKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetDeferredOperationResultKHR( m_device, static_cast<VkDeferredOperationKHR>( operation ) ) ); |
| } |
| #else |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result |
| Device::getDeferredOperationResultKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetDeferredOperationResultKHR && "Function <vkGetDeferredOperationResultKHR> requires <VK_KHR_deferred_host_operations>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = |
| static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetDeferredOperationResultKHR( m_device, static_cast<VkDeferredOperationKHR>( operation ) ) ); |
| |
| return static_cast<VULKAN_HPP_NAMESPACE::Result>( result ); |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::deferredOperationJoinKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkDeferredOperationJoinKHR( m_device, static_cast<VkDeferredOperationKHR>( operation ) ) ); |
| } |
| #else |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result Device::deferredOperationJoinKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDeferredOperationJoinKHR && "Function <vkDeferredOperationJoinKHR> requires <VK_KHR_deferred_host_operations>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = |
| static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkDeferredOperationJoinKHR( m_device, static_cast<VkDeferredOperationKHR>( operation ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( |
| result, |
| VULKAN_HPP_NAMESPACE_STRING "::Device::deferredOperationJoinKHR", |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eThreadDoneKHR, VULKAN_HPP_NAMESPACE::Result::eThreadIdleKHR } ); |
| |
| return static_cast<VULKAN_HPP_NAMESPACE::Result>( result ); |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| //=== VK_KHR_pipeline_executable_properties === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getPipelineExecutablePropertiesKHR( const VULKAN_HPP_NAMESPACE::PipelineInfoKHR * pPipelineInfo, |
| uint32_t * pExecutableCount, |
| VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR * pProperties, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetPipelineExecutablePropertiesKHR( m_device, |
| reinterpret_cast<const VkPipelineInfoKHR *>( pPipelineInfo ), |
| pExecutableCount, |
| reinterpret_cast<VkPipelineExecutablePropertiesKHR *>( pProperties ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename PipelineExecutablePropertiesKHRAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE |
| typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR, PipelineExecutablePropertiesKHRAllocator>>::type |
| Device::getPipelineExecutablePropertiesKHR( const VULKAN_HPP_NAMESPACE::PipelineInfoKHR & pipelineInfo, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPipelineExecutablePropertiesKHR && |
| "Function <vkGetPipelineExecutablePropertiesKHR> requires <VK_KHR_pipeline_executable_properties>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR, PipelineExecutablePropertiesKHRAllocator> properties; |
| uint32_t executableCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetPipelineExecutablePropertiesKHR( m_device, reinterpret_cast<const VkPipelineInfoKHR *>( &pipelineInfo ), &executableCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && executableCount ) |
| { |
| properties.resize( executableCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetPipelineExecutablePropertiesKHR( m_device, |
| reinterpret_cast<const VkPipelineInfoKHR *>( &pipelineInfo ), |
| &executableCount, |
| reinterpret_cast<VkPipelineExecutablePropertiesKHR *>( properties.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineExecutablePropertiesKHR" ); |
| VULKAN_HPP_ASSERT( executableCount <= properties.size() ); |
| if ( executableCount < properties.size() ) |
| { |
| properties.resize( executableCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); |
| } |
| |
| template <typename PipelineExecutablePropertiesKHRAllocator, |
| typename Dispatch, |
| typename std::enable_if< |
| std::is_same<typename PipelineExecutablePropertiesKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR>::value, |
| int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE |
| typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR, PipelineExecutablePropertiesKHRAllocator>>::type |
| Device::getPipelineExecutablePropertiesKHR( const VULKAN_HPP_NAMESPACE::PipelineInfoKHR & pipelineInfo, |
| PipelineExecutablePropertiesKHRAllocator & pipelineExecutablePropertiesKHRAllocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPipelineExecutablePropertiesKHR && |
| "Function <vkGetPipelineExecutablePropertiesKHR> requires <VK_KHR_pipeline_executable_properties>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR, PipelineExecutablePropertiesKHRAllocator> properties( |
| pipelineExecutablePropertiesKHRAllocator ); |
| uint32_t executableCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetPipelineExecutablePropertiesKHR( m_device, reinterpret_cast<const VkPipelineInfoKHR *>( &pipelineInfo ), &executableCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && executableCount ) |
| { |
| properties.resize( executableCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetPipelineExecutablePropertiesKHR( m_device, |
| reinterpret_cast<const VkPipelineInfoKHR *>( &pipelineInfo ), |
| &executableCount, |
| reinterpret_cast<VkPipelineExecutablePropertiesKHR *>( properties.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineExecutablePropertiesKHR" ); |
| VULKAN_HPP_ASSERT( executableCount <= properties.size() ); |
| if ( executableCount < properties.size() ) |
| { |
| properties.resize( executableCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| Device::getPipelineExecutableStatisticsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR * pExecutableInfo, |
| uint32_t * pStatisticCount, |
| VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR * pStatistics, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetPipelineExecutableStatisticsKHR( m_device, |
| reinterpret_cast<const VkPipelineExecutableInfoKHR *>( pExecutableInfo ), |
| pStatisticCount, |
| reinterpret_cast<VkPipelineExecutableStatisticKHR *>( pStatistics ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename PipelineExecutableStatisticKHRAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE |
| typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR, PipelineExecutableStatisticKHRAllocator>>::type |
| Device::getPipelineExecutableStatisticsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPipelineExecutableStatisticsKHR && |
| "Function <vkGetPipelineExecutableStatisticsKHR> requires <VK_KHR_pipeline_executable_properties>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR, PipelineExecutableStatisticKHRAllocator> statistics; |
| uint32_t statisticCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPipelineExecutableStatisticsKHR( |
| m_device, reinterpret_cast<const VkPipelineExecutableInfoKHR *>( &executableInfo ), &statisticCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && statisticCount ) |
| { |
| statistics.resize( statisticCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetPipelineExecutableStatisticsKHR( m_device, |
| reinterpret_cast<const VkPipelineExecutableInfoKHR *>( &executableInfo ), |
| &statisticCount, |
| reinterpret_cast<VkPipelineExecutableStatisticKHR *>( statistics.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineExecutableStatisticsKHR" ); |
| VULKAN_HPP_ASSERT( statisticCount <= statistics.size() ); |
| if ( statisticCount < statistics.size() ) |
| { |
| statistics.resize( statisticCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( statistics ) ); |
| } |
| |
| template <typename PipelineExecutableStatisticKHRAllocator, |
| typename Dispatch, |
| typename std::enable_if< |
| std::is_same<typename PipelineExecutableStatisticKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR>::value, |
| int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE |
| typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR, PipelineExecutableStatisticKHRAllocator>>::type |
| Device::getPipelineExecutableStatisticsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo, |
| PipelineExecutableStatisticKHRAllocator & pipelineExecutableStatisticKHRAllocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPipelineExecutableStatisticsKHR && |
| "Function <vkGetPipelineExecutableStatisticsKHR> requires <VK_KHR_pipeline_executable_properties>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR, PipelineExecutableStatisticKHRAllocator> statistics( |
| pipelineExecutableStatisticKHRAllocator ); |
| uint32_t statisticCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPipelineExecutableStatisticsKHR( |
| m_device, reinterpret_cast<const VkPipelineExecutableInfoKHR *>( &executableInfo ), &statisticCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && statisticCount ) |
| { |
| statistics.resize( statisticCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetPipelineExecutableStatisticsKHR( m_device, |
| reinterpret_cast<const VkPipelineExecutableInfoKHR *>( &executableInfo ), |
| &statisticCount, |
| reinterpret_cast<VkPipelineExecutableStatisticKHR *>( statistics.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineExecutableStatisticsKHR" ); |
| VULKAN_HPP_ASSERT( statisticCount <= statistics.size() ); |
| if ( statisticCount < statistics.size() ) |
| { |
| statistics.resize( statisticCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( statistics ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| Device::getPipelineExecutableInternalRepresentationsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR * pExecutableInfo, |
| uint32_t * pInternalRepresentationCount, |
| VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR * pInternalRepresentations, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( |
| d.vkGetPipelineExecutableInternalRepresentationsKHR( m_device, |
| reinterpret_cast<const VkPipelineExecutableInfoKHR *>( pExecutableInfo ), |
| pInternalRepresentationCount, |
| reinterpret_cast<VkPipelineExecutableInternalRepresentationKHR *>( pInternalRepresentations ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename PipelineExecutableInternalRepresentationKHRAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType< |
| std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR, PipelineExecutableInternalRepresentationKHRAllocator>>::type |
| Device::getPipelineExecutableInternalRepresentationsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPipelineExecutableInternalRepresentationsKHR && |
| "Function <vkGetPipelineExecutableInternalRepresentationsKHR> requires <VK_KHR_pipeline_executable_properties>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR, PipelineExecutableInternalRepresentationKHRAllocator> |
| internalRepresentations; |
| uint32_t internalRepresentationCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPipelineExecutableInternalRepresentationsKHR( |
| m_device, reinterpret_cast<const VkPipelineExecutableInfoKHR *>( &executableInfo ), &internalRepresentationCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && internalRepresentationCount ) |
| { |
| internalRepresentations.resize( internalRepresentationCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPipelineExecutableInternalRepresentationsKHR( |
| m_device, |
| reinterpret_cast<const VkPipelineExecutableInfoKHR *>( &executableInfo ), |
| &internalRepresentationCount, |
| reinterpret_cast<VkPipelineExecutableInternalRepresentationKHR *>( internalRepresentations.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineExecutableInternalRepresentationsKHR" ); |
| VULKAN_HPP_ASSERT( internalRepresentationCount <= internalRepresentations.size() ); |
| if ( internalRepresentationCount < internalRepresentations.size() ) |
| { |
| internalRepresentations.resize( internalRepresentationCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( internalRepresentations ) ); |
| } |
| |
| template <typename PipelineExecutableInternalRepresentationKHRAllocator, |
| typename Dispatch, |
| typename std::enable_if<std::is_same<typename PipelineExecutableInternalRepresentationKHRAllocator::value_type, |
| VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR>::value, |
| int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType< |
| std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR, PipelineExecutableInternalRepresentationKHRAllocator>>::type |
| Device::getPipelineExecutableInternalRepresentationsKHR( |
| const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo, |
| PipelineExecutableInternalRepresentationKHRAllocator & pipelineExecutableInternalRepresentationKHRAllocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPipelineExecutableInternalRepresentationsKHR && |
| "Function <vkGetPipelineExecutableInternalRepresentationsKHR> requires <VK_KHR_pipeline_executable_properties>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR, PipelineExecutableInternalRepresentationKHRAllocator> |
| internalRepresentations( pipelineExecutableInternalRepresentationKHRAllocator ); |
| uint32_t internalRepresentationCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPipelineExecutableInternalRepresentationsKHR( |
| m_device, reinterpret_cast<const VkPipelineExecutableInfoKHR *>( &executableInfo ), &internalRepresentationCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && internalRepresentationCount ) |
| { |
| internalRepresentations.resize( internalRepresentationCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPipelineExecutableInternalRepresentationsKHR( |
| m_device, |
| reinterpret_cast<const VkPipelineExecutableInfoKHR *>( &executableInfo ), |
| &internalRepresentationCount, |
| reinterpret_cast<VkPipelineExecutableInternalRepresentationKHR *>( internalRepresentations.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineExecutableInternalRepresentationsKHR" ); |
| VULKAN_HPP_ASSERT( internalRepresentationCount <= internalRepresentations.size() ); |
| if ( internalRepresentationCount < internalRepresentations.size() ) |
| { |
| internalRepresentations.resize( internalRepresentationCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( internalRepresentations ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_EXT_host_image_copy === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyMemoryToImageEXT( const VULKAN_HPP_NAMESPACE::CopyMemoryToImageInfoEXT * pCopyMemoryToImageInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCopyMemoryToImageEXT( m_device, reinterpret_cast<const VkCopyMemoryToImageInfoEXT *>( pCopyMemoryToImageInfo ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type |
| Device::copyMemoryToImageEXT( const VULKAN_HPP_NAMESPACE::CopyMemoryToImageInfoEXT & copyMemoryToImageInfo, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCopyMemoryToImageEXT && "Function <vkCopyMemoryToImageEXT> requires <VK_EXT_host_image_copy>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCopyMemoryToImageEXT( m_device, reinterpret_cast<const VkCopyMemoryToImageInfoEXT *>( ©MemoryToImageInfo ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::copyMemoryToImageEXT" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyImageToMemoryEXT( const VULKAN_HPP_NAMESPACE::CopyImageToMemoryInfoEXT * pCopyImageToMemoryInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCopyImageToMemoryEXT( m_device, reinterpret_cast<const VkCopyImageToMemoryInfoEXT *>( pCopyImageToMemoryInfo ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type |
| Device::copyImageToMemoryEXT( const VULKAN_HPP_NAMESPACE::CopyImageToMemoryInfoEXT & copyImageToMemoryInfo, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCopyImageToMemoryEXT && "Function <vkCopyImageToMemoryEXT> requires <VK_EXT_host_image_copy>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCopyImageToMemoryEXT( m_device, reinterpret_cast<const VkCopyImageToMemoryInfoEXT *>( ©ImageToMemoryInfo ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::copyImageToMemoryEXT" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyImageToImageEXT( const VULKAN_HPP_NAMESPACE::CopyImageToImageInfoEXT * pCopyImageToImageInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCopyImageToImageEXT( m_device, reinterpret_cast<const VkCopyImageToImageInfoEXT *>( pCopyImageToImageInfo ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type |
| Device::copyImageToImageEXT( const VULKAN_HPP_NAMESPACE::CopyImageToImageInfoEXT & copyImageToImageInfo, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCopyImageToImageEXT && "Function <vkCopyImageToImageEXT> requires <VK_EXT_host_image_copy>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCopyImageToImageEXT( m_device, reinterpret_cast<const VkCopyImageToImageInfoEXT *>( ©ImageToImageInfo ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::copyImageToImageEXT" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::transitionImageLayoutEXT( uint32_t transitionCount, |
| const VULKAN_HPP_NAMESPACE::HostImageLayoutTransitionInfoEXT * pTransitions, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( |
| d.vkTransitionImageLayoutEXT( m_device, transitionCount, reinterpret_cast<const VkHostImageLayoutTransitionInfoEXT *>( pTransitions ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type |
| Device::transitionImageLayoutEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::HostImageLayoutTransitionInfoEXT> const & transitions, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkTransitionImageLayoutEXT && "Function <vkTransitionImageLayoutEXT> requires <VK_EXT_host_image_copy>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkTransitionImageLayoutEXT( m_device, transitions.size(), reinterpret_cast<const VkHostImageLayoutTransitionInfoEXT *>( transitions.data() ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::transitionImageLayoutEXT" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::getImageSubresourceLayout2EXT( VULKAN_HPP_NAMESPACE::Image image, |
| const VULKAN_HPP_NAMESPACE::ImageSubresource2KHR * pSubresource, |
| VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR * pLayout, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetImageSubresourceLayout2EXT( m_device, |
| static_cast<VkImage>( image ), |
| reinterpret_cast<const VkImageSubresource2KHR *>( pSubresource ), |
| reinterpret_cast<VkSubresourceLayout2KHR *>( pLayout ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR Device::getImageSubresourceLayout2EXT( |
| VULKAN_HPP_NAMESPACE::Image image, const VULKAN_HPP_NAMESPACE::ImageSubresource2KHR & subresource, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( |
| d.vkGetImageSubresourceLayout2EXT && |
| "Function <vkGetImageSubresourceLayout2EXT> requires <VK_EXT_host_image_copy> or <VK_EXT_image_compression_control> or <VK_KHR_maintenance5>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR layout; |
| d.vkGetImageSubresourceLayout2EXT( m_device, |
| static_cast<VkImage>( image ), |
| reinterpret_cast<const VkImageSubresource2KHR *>( &subresource ), |
| reinterpret_cast<VkSubresourceLayout2KHR *>( &layout ) ); |
| |
| return layout; |
| } |
| |
| template <typename X, typename Y, typename... Z, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> Device::getImageSubresourceLayout2EXT( |
| VULKAN_HPP_NAMESPACE::Image image, const VULKAN_HPP_NAMESPACE::ImageSubresource2KHR & subresource, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( |
| d.vkGetImageSubresourceLayout2EXT && |
| "Function <vkGetImageSubresourceLayout2EXT> requires <VK_EXT_host_image_copy> or <VK_EXT_image_compression_control> or <VK_KHR_maintenance5>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain; |
| VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR & layout = structureChain.template get<VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR>(); |
| d.vkGetImageSubresourceLayout2EXT( m_device, |
| static_cast<VkImage>( image ), |
| reinterpret_cast<const VkImageSubresource2KHR *>( &subresource ), |
| reinterpret_cast<VkSubresourceLayout2KHR *>( &layout ) ); |
| |
| return structureChain; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_KHR_map_memory2 === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::mapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryMapInfoKHR * pMemoryMapInfo, |
| void ** ppData, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkMapMemory2KHR( m_device, reinterpret_cast<const VkMemoryMapInfoKHR *>( pMemoryMapInfo ), ppData ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<void *>::type |
| Device::mapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryMapInfoKHR & memoryMapInfo, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkMapMemory2KHR && "Function <vkMapMemory2KHR> requires <VK_KHR_map_memory2>" ); |
| # endif |
| |
| void * pData; |
| VULKAN_HPP_NAMESPACE::Result result = |
| static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkMapMemory2KHR( m_device, reinterpret_cast<const VkMemoryMapInfoKHR *>( &memoryMapInfo ), &pData ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::mapMemory2KHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( pData ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::unmapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryUnmapInfoKHR * pMemoryUnmapInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkUnmapMemory2KHR( m_device, reinterpret_cast<const VkMemoryUnmapInfoKHR *>( pMemoryUnmapInfo ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::unmapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryUnmapInfoKHR & memoryUnmapInfo, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkUnmapMemory2KHR && "Function <vkUnmapMemory2KHR> requires <VK_KHR_map_memory2>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = |
| static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkUnmapMemory2KHR( m_device, reinterpret_cast<const VkMemoryUnmapInfoKHR *>( &memoryUnmapInfo ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::unmapMemory2KHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_EXT_swapchain_maintenance1 === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::releaseSwapchainImagesEXT( const VULKAN_HPP_NAMESPACE::ReleaseSwapchainImagesInfoEXT * pReleaseInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkReleaseSwapchainImagesEXT( m_device, reinterpret_cast<const VkReleaseSwapchainImagesInfoEXT *>( pReleaseInfo ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE typename ResultValueType<void>::type |
| Device::releaseSwapchainImagesEXT( const VULKAN_HPP_NAMESPACE::ReleaseSwapchainImagesInfoEXT & releaseInfo, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkReleaseSwapchainImagesEXT && "Function <vkReleaseSwapchainImagesEXT> requires <VK_EXT_swapchain_maintenance1>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkReleaseSwapchainImagesEXT( m_device, reinterpret_cast<const VkReleaseSwapchainImagesInfoEXT *>( &releaseInfo ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::releaseSwapchainImagesEXT" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_NV_device_generated_commands === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::getGeneratedCommandsMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV * pInfo, |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetGeneratedCommandsMemoryRequirementsNV( m_device, |
| reinterpret_cast<const VkGeneratedCommandsMemoryRequirementsInfoNV *>( pInfo ), |
| reinterpret_cast<VkMemoryRequirements2 *>( pMemoryRequirements ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2 |
| Device::getGeneratedCommandsMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV & info, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetGeneratedCommandsMemoryRequirementsNV && |
| "Function <vkGetGeneratedCommandsMemoryRequirementsNV> requires <VK_NV_device_generated_commands>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements; |
| d.vkGetGeneratedCommandsMemoryRequirementsNV( m_device, |
| reinterpret_cast<const VkGeneratedCommandsMemoryRequirementsInfoNV *>( &info ), |
| reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) ); |
| |
| return memoryRequirements; |
| } |
| |
| template <typename X, typename Y, typename... Z, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> |
| Device::getGeneratedCommandsMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV & info, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetGeneratedCommandsMemoryRequirementsNV && |
| "Function <vkGetGeneratedCommandsMemoryRequirementsNV> requires <VK_NV_device_generated_commands>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain; |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>(); |
| d.vkGetGeneratedCommandsMemoryRequirementsNV( m_device, |
| reinterpret_cast<const VkGeneratedCommandsMemoryRequirementsInfoNV *>( &info ), |
| reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) ); |
| |
| return structureChain; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::preprocessGeneratedCommandsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV * pGeneratedCommandsInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdPreprocessGeneratedCommandsNV( m_commandBuffer, reinterpret_cast<const VkGeneratedCommandsInfoNV *>( pGeneratedCommandsInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::preprocessGeneratedCommandsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV & generatedCommandsInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdPreprocessGeneratedCommandsNV && "Function <vkCmdPreprocessGeneratedCommandsNV> requires <VK_NV_device_generated_commands>" ); |
| # endif |
| |
| d.vkCmdPreprocessGeneratedCommandsNV( m_commandBuffer, reinterpret_cast<const VkGeneratedCommandsInfoNV *>( &generatedCommandsInfo ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::executeGeneratedCommandsNV( VULKAN_HPP_NAMESPACE::Bool32 isPreprocessed, |
| const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV * pGeneratedCommandsInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdExecuteGeneratedCommandsNV( |
| m_commandBuffer, static_cast<VkBool32>( isPreprocessed ), reinterpret_cast<const VkGeneratedCommandsInfoNV *>( pGeneratedCommandsInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::executeGeneratedCommandsNV( VULKAN_HPP_NAMESPACE::Bool32 isPreprocessed, |
| const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV & generatedCommandsInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdExecuteGeneratedCommandsNV && "Function <vkCmdExecuteGeneratedCommandsNV> requires <VK_NV_device_generated_commands>" ); |
| # endif |
| |
| d.vkCmdExecuteGeneratedCommandsNV( |
| m_commandBuffer, static_cast<VkBool32>( isPreprocessed ), reinterpret_cast<const VkGeneratedCommandsInfoNV *>( &generatedCommandsInfo ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::bindPipelineShaderGroupNV( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, |
| VULKAN_HPP_NAMESPACE::Pipeline pipeline, |
| uint32_t groupIndex, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdBindPipelineShaderGroupNV( m_commandBuffer, static_cast<VkPipelineBindPoint>( pipelineBindPoint ), static_cast<VkPipeline>( pipeline ), groupIndex ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| Device::createIndirectCommandsLayoutNV( const VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV * pIndirectCommandsLayout, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateIndirectCommandsLayoutNV( m_device, |
| reinterpret_cast<const VkIndirectCommandsLayoutCreateInfoNV *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkIndirectCommandsLayoutNV *>( pIndirectCommandsLayout ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV>::type |
| Device::createIndirectCommandsLayoutNV( const VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateIndirectCommandsLayoutNV && "Function <vkCreateIndirectCommandsLayoutNV> requires <VK_NV_device_generated_commands>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateIndirectCommandsLayoutNV( |
| m_device, |
| reinterpret_cast<const VkIndirectCommandsLayoutCreateInfoNV *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkIndirectCommandsLayoutNV *>( &indirectCommandsLayout ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createIndirectCommandsLayoutNV" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( indirectCommandsLayout ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV, Dispatch>>::type |
| Device::createIndirectCommandsLayoutNVUnique( const VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateIndirectCommandsLayoutNV && "Function <vkCreateIndirectCommandsLayoutNV> requires <VK_NV_device_generated_commands>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateIndirectCommandsLayoutNV( |
| m_device, |
| reinterpret_cast<const VkIndirectCommandsLayoutCreateInfoNV *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkIndirectCommandsLayoutNV *>( &indirectCommandsLayout ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createIndirectCommandsLayoutNVUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, |
| UniqueHandle<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV, Dispatch>( |
| indirectCommandsLayout, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyIndirectCommandsLayoutNV( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyIndirectCommandsLayoutNV( |
| m_device, static_cast<VkIndirectCommandsLayoutNV>( indirectCommandsLayout ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyIndirectCommandsLayoutNV( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyIndirectCommandsLayoutNV && "Function <vkDestroyIndirectCommandsLayoutNV> requires <VK_NV_device_generated_commands>" ); |
| # endif |
| |
| d.vkDestroyIndirectCommandsLayoutNV( |
| m_device, |
| static_cast<VkIndirectCommandsLayoutNV>( indirectCommandsLayout ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyIndirectCommandsLayoutNV( |
| m_device, static_cast<VkIndirectCommandsLayoutNV>( indirectCommandsLayout ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyIndirectCommandsLayoutNV && "Function <vkDestroyIndirectCommandsLayoutNV> requires <VK_NV_device_generated_commands>" ); |
| # endif |
| |
| d.vkDestroyIndirectCommandsLayoutNV( |
| m_device, |
| static_cast<VkIndirectCommandsLayoutNV>( indirectCommandsLayout ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_EXT_depth_bias_control === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setDepthBias2EXT( const VULKAN_HPP_NAMESPACE::DepthBiasInfoEXT * pDepthBiasInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetDepthBias2EXT( m_commandBuffer, reinterpret_cast<const VkDepthBiasInfoEXT *>( pDepthBiasInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setDepthBias2EXT( const VULKAN_HPP_NAMESPACE::DepthBiasInfoEXT & depthBiasInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdSetDepthBias2EXT && "Function <vkCmdSetDepthBias2EXT> requires <VK_EXT_depth_bias_control>" ); |
| # endif |
| |
| d.vkCmdSetDepthBias2EXT( m_commandBuffer, reinterpret_cast<const VkDepthBiasInfoEXT *>( &depthBiasInfo ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_EXT_acquire_drm_display === |
| |
| #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::acquireDrmDisplayEXT( int32_t drmFd, |
| VULKAN_HPP_NAMESPACE::DisplayKHR display, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkAcquireDrmDisplayEXT( m_physicalDevice, drmFd, static_cast<VkDisplayKHR>( display ) ) ); |
| } |
| #else |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE typename ResultValueType<void>::type |
| PhysicalDevice::acquireDrmDisplayEXT( int32_t drmFd, VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkAcquireDrmDisplayEXT && "Function <vkAcquireDrmDisplayEXT> requires <VK_EXT_acquire_drm_display>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = |
| static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkAcquireDrmDisplayEXT( m_physicalDevice, drmFd, static_cast<VkDisplayKHR>( display ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::acquireDrmDisplayEXT" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getDrmDisplayEXT( int32_t drmFd, |
| uint32_t connectorId, |
| VULKAN_HPP_NAMESPACE::DisplayKHR * display, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetDrmDisplayEXT( m_physicalDevice, drmFd, connectorId, reinterpret_cast<VkDisplayKHR *>( display ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayKHR>::type |
| PhysicalDevice::getDrmDisplayEXT( int32_t drmFd, uint32_t connectorId, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetDrmDisplayEXT && "Function <vkGetDrmDisplayEXT> requires <VK_EXT_acquire_drm_display>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::DisplayKHR display; |
| VULKAN_HPP_NAMESPACE::Result result = |
| static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetDrmDisplayEXT( m_physicalDevice, drmFd, connectorId, reinterpret_cast<VkDisplayKHR *>( &display ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDrmDisplayEXT" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( display ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>>::type |
| PhysicalDevice::getDrmDisplayEXTUnique( int32_t drmFd, uint32_t connectorId, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetDrmDisplayEXT && "Function <vkGetDrmDisplayEXT> requires <VK_EXT_acquire_drm_display>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::DisplayKHR display; |
| VULKAN_HPP_NAMESPACE::Result result = |
| static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetDrmDisplayEXT( m_physicalDevice, drmFd, connectorId, reinterpret_cast<VkDisplayKHR *>( &display ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDrmDisplayEXTUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>( display, ObjectRelease<PhysicalDevice, Dispatch>( *this, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_EXT_private_data === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createPrivateDataSlotEXT( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::PrivateDataSlot * pPrivateDataSlot, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreatePrivateDataSlotEXT( m_device, |
| reinterpret_cast<const VkPrivateDataSlotCreateInfo *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkPrivateDataSlot *>( pPrivateDataSlot ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::PrivateDataSlot>::type |
| Device::createPrivateDataSlotEXT( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreatePrivateDataSlotEXT && "Function <vkCreatePrivateDataSlotEXT> requires <VK_EXT_private_data> or <VK_VERSION_1_3>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreatePrivateDataSlotEXT( |
| m_device, |
| reinterpret_cast<const VkPrivateDataSlotCreateInfo *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkPrivateDataSlot *>( &privateDataSlot ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createPrivateDataSlotEXT" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( privateDataSlot ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PrivateDataSlot, Dispatch>>::type |
| Device::createPrivateDataSlotEXTUnique( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreatePrivateDataSlotEXT && "Function <vkCreatePrivateDataSlotEXT> requires <VK_EXT_private_data> or <VK_VERSION_1_3>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreatePrivateDataSlotEXT( |
| m_device, |
| reinterpret_cast<const VkPrivateDataSlotCreateInfo *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkPrivateDataSlot *>( &privateDataSlot ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createPrivateDataSlotEXTUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::PrivateDataSlot, Dispatch>( privateDataSlot, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyPrivateDataSlotEXT( VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyPrivateDataSlotEXT( m_device, static_cast<VkPrivateDataSlot>( privateDataSlot ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyPrivateDataSlotEXT( VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyPrivateDataSlotEXT && "Function <vkDestroyPrivateDataSlotEXT> requires <VK_EXT_private_data> or <VK_VERSION_1_3>" ); |
| # endif |
| |
| d.vkDestroyPrivateDataSlotEXT( |
| m_device, |
| static_cast<VkPrivateDataSlot>( privateDataSlot ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::setPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType objectType_, |
| uint64_t objectHandle, |
| VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, |
| uint64_t data, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( |
| d.vkSetPrivateDataEXT( m_device, static_cast<VkObjectType>( objectType_ ), objectHandle, static_cast<VkPrivateDataSlot>( privateDataSlot ), data ) ); |
| } |
| #else |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::setPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType objectType_, |
| uint64_t objectHandle, |
| VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, |
| uint64_t data, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkSetPrivateDataEXT && "Function <vkSetPrivateDataEXT> requires <VK_EXT_private_data> or <VK_VERSION_1_3>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkSetPrivateDataEXT( m_device, static_cast<VkObjectType>( objectType_ ), objectHandle, static_cast<VkPrivateDataSlot>( privateDataSlot ), data ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setPrivateDataEXT" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::getPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType objectType_, |
| uint64_t objectHandle, |
| VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, |
| uint64_t * pData, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetPrivateDataEXT( m_device, static_cast<VkObjectType>( objectType_ ), objectHandle, static_cast<VkPrivateDataSlot>( privateDataSlot ), pData ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t Device::getPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType objectType_, |
| uint64_t objectHandle, |
| VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPrivateDataEXT && "Function <vkGetPrivateDataEXT> requires <VK_EXT_private_data> or <VK_VERSION_1_3>" ); |
| # endif |
| |
| uint64_t data; |
| d.vkGetPrivateDataEXT( m_device, static_cast<VkObjectType>( objectType_ ), objectHandle, static_cast<VkPrivateDataSlot>( privateDataSlot ), &data ); |
| |
| return data; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_KHR_video_encode_queue === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| PhysicalDevice::getVideoEncodeQualityLevelPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR * pQualityLevelInfo, |
| VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelPropertiesKHR * pQualityLevelProperties, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( |
| d.vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( m_physicalDevice, |
| reinterpret_cast<const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR *>( pQualityLevelInfo ), |
| reinterpret_cast<VkVideoEncodeQualityLevelPropertiesKHR *>( pQualityLevelProperties ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelPropertiesKHR>::type |
| PhysicalDevice::getVideoEncodeQualityLevelPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR & qualityLevelInfo, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR && |
| "Function <vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR> requires <VK_KHR_video_encode_queue>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelPropertiesKHR qualityLevelProperties; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( m_physicalDevice, |
| reinterpret_cast<const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR *>( &qualityLevelInfo ), |
| reinterpret_cast<VkVideoEncodeQualityLevelPropertiesKHR *>( &qualityLevelProperties ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoEncodeQualityLevelPropertiesKHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( qualityLevelProperties ) ); |
| } |
| |
| template <typename X, typename Y, typename... Z, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>>::type |
| PhysicalDevice::getVideoEncodeQualityLevelPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR & qualityLevelInfo, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR && |
| "Function <vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR> requires <VK_KHR_video_encode_queue>" ); |
| # endif |
| |
| StructureChain<X, Y, Z...> structureChain; |
| VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelPropertiesKHR & qualityLevelProperties = |
| structureChain.template get<VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelPropertiesKHR>(); |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( m_physicalDevice, |
| reinterpret_cast<const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR *>( &qualityLevelInfo ), |
| reinterpret_cast<VkVideoEncodeQualityLevelPropertiesKHR *>( &qualityLevelProperties ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoEncodeQualityLevelPropertiesKHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( structureChain ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| Device::getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR * pVideoSessionParametersInfo, |
| VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR * pFeedbackInfo, |
| size_t * pDataSize, |
| void * pData, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( |
| d.vkGetEncodedVideoSessionParametersKHR( m_device, |
| reinterpret_cast<const VkVideoEncodeSessionParametersGetInfoKHR *>( pVideoSessionParametersInfo ), |
| reinterpret_cast<VkVideoEncodeSessionParametersFeedbackInfoKHR *>( pFeedbackInfo ), |
| pDataSize, |
| pData ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Uint8_tAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE |
| typename ResultValueType<std::pair<VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR, std::vector<uint8_t, Uint8_tAllocator>>>::type |
| Device::getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetEncodedVideoSessionParametersKHR && "Function <vkGetEncodedVideoSessionParametersKHR> requires <VK_KHR_video_encode_queue>" ); |
| # endif |
| |
| std::pair<VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR, std::vector<uint8_t, Uint8_tAllocator>> data_; |
| VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR & feedbackInfo = data_.first; |
| std::vector<uint8_t, Uint8_tAllocator> & data = data_.second; |
| size_t dataSize; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetEncodedVideoSessionParametersKHR( m_device, |
| reinterpret_cast<const VkVideoEncodeSessionParametersGetInfoKHR *>( &videoSessionParametersInfo ), |
| reinterpret_cast<VkVideoEncodeSessionParametersFeedbackInfoKHR *>( &feedbackInfo ), |
| &dataSize, |
| nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && dataSize ) |
| { |
| data.resize( dataSize ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetEncodedVideoSessionParametersKHR( m_device, |
| reinterpret_cast<const VkVideoEncodeSessionParametersGetInfoKHR *>( &videoSessionParametersInfo ), |
| reinterpret_cast<VkVideoEncodeSessionParametersFeedbackInfoKHR *>( &feedbackInfo ), |
| &dataSize, |
| reinterpret_cast<void *>( data.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getEncodedVideoSessionParametersKHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data_ ) ); |
| } |
| |
| template <typename Uint8_tAllocator, |
| typename Dispatch, |
| typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE |
| typename ResultValueType<std::pair<VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR, std::vector<uint8_t, Uint8_tAllocator>>>::type |
| Device::getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo, |
| Uint8_tAllocator & uint8_tAllocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetEncodedVideoSessionParametersKHR && "Function <vkGetEncodedVideoSessionParametersKHR> requires <VK_KHR_video_encode_queue>" ); |
| # endif |
| |
| std::pair<VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR, std::vector<uint8_t, Uint8_tAllocator>> data_( |
| std::piecewise_construct, std::forward_as_tuple(), std::forward_as_tuple( uint8_tAllocator ) ); |
| VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR & feedbackInfo = data_.first; |
| std::vector<uint8_t, Uint8_tAllocator> & data = data_.second; |
| size_t dataSize; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetEncodedVideoSessionParametersKHR( m_device, |
| reinterpret_cast<const VkVideoEncodeSessionParametersGetInfoKHR *>( &videoSessionParametersInfo ), |
| reinterpret_cast<VkVideoEncodeSessionParametersFeedbackInfoKHR *>( &feedbackInfo ), |
| &dataSize, |
| nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && dataSize ) |
| { |
| data.resize( dataSize ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetEncodedVideoSessionParametersKHR( m_device, |
| reinterpret_cast<const VkVideoEncodeSessionParametersGetInfoKHR *>( &videoSessionParametersInfo ), |
| reinterpret_cast<VkVideoEncodeSessionParametersFeedbackInfoKHR *>( &feedbackInfo ), |
| &dataSize, |
| reinterpret_cast<void *>( data.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getEncodedVideoSessionParametersKHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data_ ) ); |
| } |
| |
| template <typename X, typename Y, typename... Z, typename Uint8_tAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE |
| typename ResultValueType<std::pair<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>, std::vector<uint8_t, Uint8_tAllocator>>>::type |
| Device::getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetEncodedVideoSessionParametersKHR && "Function <vkGetEncodedVideoSessionParametersKHR> requires <VK_KHR_video_encode_queue>" ); |
| # endif |
| |
| std::pair<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>, std::vector<uint8_t, Uint8_tAllocator>> data_; |
| VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR & feedbackInfo = |
| data_.first.template get<VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR>(); |
| std::vector<uint8_t, Uint8_tAllocator> & data = data_.second; |
| size_t dataSize; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetEncodedVideoSessionParametersKHR( m_device, |
| reinterpret_cast<const VkVideoEncodeSessionParametersGetInfoKHR *>( &videoSessionParametersInfo ), |
| reinterpret_cast<VkVideoEncodeSessionParametersFeedbackInfoKHR *>( &feedbackInfo ), |
| &dataSize, |
| nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && dataSize ) |
| { |
| data.resize( dataSize ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetEncodedVideoSessionParametersKHR( m_device, |
| reinterpret_cast<const VkVideoEncodeSessionParametersGetInfoKHR *>( &videoSessionParametersInfo ), |
| reinterpret_cast<VkVideoEncodeSessionParametersFeedbackInfoKHR *>( &feedbackInfo ), |
| &dataSize, |
| reinterpret_cast<void *>( data.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getEncodedVideoSessionParametersKHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data_ ) ); |
| } |
| |
| template <typename X, |
| typename Y, |
| typename... Z, |
| typename Uint8_tAllocator, |
| typename Dispatch, |
| typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE |
| typename ResultValueType<std::pair<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>, std::vector<uint8_t, Uint8_tAllocator>>>::type |
| Device::getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo, |
| Uint8_tAllocator & uint8_tAllocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetEncodedVideoSessionParametersKHR && "Function <vkGetEncodedVideoSessionParametersKHR> requires <VK_KHR_video_encode_queue>" ); |
| # endif |
| |
| std::pair<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>, std::vector<uint8_t, Uint8_tAllocator>> data_( |
| std::piecewise_construct, std::forward_as_tuple(), std::forward_as_tuple( uint8_tAllocator ) ); |
| VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR & feedbackInfo = |
| data_.first.template get<VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR>(); |
| std::vector<uint8_t, Uint8_tAllocator> & data = data_.second; |
| size_t dataSize; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetEncodedVideoSessionParametersKHR( m_device, |
| reinterpret_cast<const VkVideoEncodeSessionParametersGetInfoKHR *>( &videoSessionParametersInfo ), |
| reinterpret_cast<VkVideoEncodeSessionParametersFeedbackInfoKHR *>( &feedbackInfo ), |
| &dataSize, |
| nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && dataSize ) |
| { |
| data.resize( dataSize ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetEncodedVideoSessionParametersKHR( m_device, |
| reinterpret_cast<const VkVideoEncodeSessionParametersGetInfoKHR *>( &videoSessionParametersInfo ), |
| reinterpret_cast<VkVideoEncodeSessionParametersFeedbackInfoKHR *>( &feedbackInfo ), |
| &dataSize, |
| reinterpret_cast<void *>( data.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getEncodedVideoSessionParametersKHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data_ ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::encodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR * pEncodeInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdEncodeVideoKHR( m_commandBuffer, reinterpret_cast<const VkVideoEncodeInfoKHR *>( pEncodeInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::encodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR & encodeInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdEncodeVideoKHR && "Function <vkCmdEncodeVideoKHR> requires <VK_KHR_video_encode_queue>" ); |
| # endif |
| |
| d.vkCmdEncodeVideoKHR( m_commandBuffer, reinterpret_cast<const VkVideoEncodeInfoKHR *>( &encodeInfo ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| #if defined( VK_ENABLE_BETA_EXTENSIONS ) |
| //=== VK_NV_cuda_kernel_launch === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createCudaModuleNV( const VULKAN_HPP_NAMESPACE::CudaModuleCreateInfoNV * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::CudaModuleNV * pModule, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateCudaModuleNV( m_device, |
| reinterpret_cast<const VkCudaModuleCreateInfoNV *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkCudaModuleNV *>( pModule ) ) ); |
| } |
| |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::CudaModuleNV>::type |
| Device::createCudaModuleNV( const VULKAN_HPP_NAMESPACE::CudaModuleCreateInfoNV & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateCudaModuleNV && "Function <vkCreateCudaModuleNV> requires <VK_NV_cuda_kernel_launch>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::CudaModuleNV module; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateCudaModuleNV( m_device, |
| reinterpret_cast<const VkCudaModuleCreateInfoNV *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkCudaModuleNV *>( &module ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createCudaModuleNV" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( module ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CudaModuleNV, Dispatch>>::type |
| Device::createCudaModuleNVUnique( const VULKAN_HPP_NAMESPACE::CudaModuleCreateInfoNV & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateCudaModuleNV && "Function <vkCreateCudaModuleNV> requires <VK_NV_cuda_kernel_launch>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::CudaModuleNV module; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateCudaModuleNV( m_device, |
| reinterpret_cast<const VkCudaModuleCreateInfoNV *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkCudaModuleNV *>( &module ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createCudaModuleNVUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::CudaModuleNV, Dispatch>( module, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getCudaModuleCacheNV( VULKAN_HPP_NAMESPACE::CudaModuleNV module, |
| size_t * pCacheSize, |
| void * pCacheData, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetCudaModuleCacheNV( m_device, static_cast<VkCudaModuleNV>( module ), pCacheSize, pCacheData ) ); |
| } |
| |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Uint8_tAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type |
| Device::getCudaModuleCacheNV( VULKAN_HPP_NAMESPACE::CudaModuleNV module, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetCudaModuleCacheNV && "Function <vkGetCudaModuleCacheNV> requires <VK_NV_cuda_kernel_launch>" ); |
| # endif |
| |
| std::vector<uint8_t, Uint8_tAllocator> cacheData; |
| size_t cacheSize; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetCudaModuleCacheNV( m_device, static_cast<VkCudaModuleNV>( module ), &cacheSize, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && cacheSize ) |
| { |
| cacheData.resize( cacheSize ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetCudaModuleCacheNV( m_device, static_cast<VkCudaModuleNV>( module ), &cacheSize, reinterpret_cast<void *>( cacheData.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getCudaModuleCacheNV" ); |
| VULKAN_HPP_ASSERT( cacheSize <= cacheData.size() ); |
| if ( cacheSize < cacheData.size() ) |
| { |
| cacheData.resize( cacheSize ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( cacheData ) ); |
| } |
| |
| template <typename Uint8_tAllocator, |
| typename Dispatch, |
| typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type |
| Device::getCudaModuleCacheNV( VULKAN_HPP_NAMESPACE::CudaModuleNV module, Uint8_tAllocator & uint8_tAllocator, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetCudaModuleCacheNV && "Function <vkGetCudaModuleCacheNV> requires <VK_NV_cuda_kernel_launch>" ); |
| # endif |
| |
| std::vector<uint8_t, Uint8_tAllocator> cacheData( uint8_tAllocator ); |
| size_t cacheSize; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetCudaModuleCacheNV( m_device, static_cast<VkCudaModuleNV>( module ), &cacheSize, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && cacheSize ) |
| { |
| cacheData.resize( cacheSize ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetCudaModuleCacheNV( m_device, static_cast<VkCudaModuleNV>( module ), &cacheSize, reinterpret_cast<void *>( cacheData.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getCudaModuleCacheNV" ); |
| VULKAN_HPP_ASSERT( cacheSize <= cacheData.size() ); |
| if ( cacheSize < cacheData.size() ) |
| { |
| cacheData.resize( cacheSize ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( cacheData ) ); |
| } |
| # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createCudaFunctionNV( const VULKAN_HPP_NAMESPACE::CudaFunctionCreateInfoNV * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::CudaFunctionNV * pFunction, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateCudaFunctionNV( m_device, |
| reinterpret_cast<const VkCudaFunctionCreateInfoNV *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkCudaFunctionNV *>( pFunction ) ) ); |
| } |
| |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::CudaFunctionNV>::type |
| Device::createCudaFunctionNV( const VULKAN_HPP_NAMESPACE::CudaFunctionCreateInfoNV & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateCudaFunctionNV && "Function <vkCreateCudaFunctionNV> requires <VK_NV_cuda_kernel_launch>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::CudaFunctionNV function; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateCudaFunctionNV( m_device, |
| reinterpret_cast<const VkCudaFunctionCreateInfoNV *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkCudaFunctionNV *>( &function ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createCudaFunctionNV" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( function ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CudaFunctionNV, Dispatch>>::type |
| Device::createCudaFunctionNVUnique( const VULKAN_HPP_NAMESPACE::CudaFunctionCreateInfoNV & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateCudaFunctionNV && "Function <vkCreateCudaFunctionNV> requires <VK_NV_cuda_kernel_launch>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::CudaFunctionNV function; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateCudaFunctionNV( m_device, |
| reinterpret_cast<const VkCudaFunctionCreateInfoNV *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkCudaFunctionNV *>( &function ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createCudaFunctionNVUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::CudaFunctionNV, Dispatch>( function, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyCudaModuleNV( VULKAN_HPP_NAMESPACE::CudaModuleNV module, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyCudaModuleNV( m_device, static_cast<VkCudaModuleNV>( module ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyCudaModuleNV( VULKAN_HPP_NAMESPACE::CudaModuleNV module, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyCudaModuleNV && "Function <vkDestroyCudaModuleNV> requires <VK_NV_cuda_kernel_launch>" ); |
| # endif |
| |
| d.vkDestroyCudaModuleNV( m_device, |
| static_cast<VkCudaModuleNV>( module ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::CudaModuleNV module, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyCudaModuleNV( m_device, static_cast<VkCudaModuleNV>( module ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::CudaModuleNV module, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyCudaModuleNV && "Function <vkDestroyCudaModuleNV> requires <VK_NV_cuda_kernel_launch>" ); |
| # endif |
| |
| d.vkDestroyCudaModuleNV( m_device, |
| static_cast<VkCudaModuleNV>( module ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyCudaFunctionNV( VULKAN_HPP_NAMESPACE::CudaFunctionNV function, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyCudaFunctionNV( m_device, static_cast<VkCudaFunctionNV>( function ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyCudaFunctionNV( VULKAN_HPP_NAMESPACE::CudaFunctionNV function, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyCudaFunctionNV && "Function <vkDestroyCudaFunctionNV> requires <VK_NV_cuda_kernel_launch>" ); |
| # endif |
| |
| d.vkDestroyCudaFunctionNV( m_device, |
| static_cast<VkCudaFunctionNV>( function ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::CudaFunctionNV function, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyCudaFunctionNV( m_device, static_cast<VkCudaFunctionNV>( function ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::CudaFunctionNV function, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyCudaFunctionNV && "Function <vkDestroyCudaFunctionNV> requires <VK_NV_cuda_kernel_launch>" ); |
| # endif |
| |
| d.vkDestroyCudaFunctionNV( m_device, |
| static_cast<VkCudaFunctionNV>( function ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::cudaLaunchKernelNV( const VULKAN_HPP_NAMESPACE::CudaLaunchInfoNV * pLaunchInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdCudaLaunchKernelNV( m_commandBuffer, reinterpret_cast<const VkCudaLaunchInfoNV *>( pLaunchInfo ) ); |
| } |
| |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::cudaLaunchKernelNV( const VULKAN_HPP_NAMESPACE::CudaLaunchInfoNV & launchInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdCudaLaunchKernelNV && "Function <vkCmdCudaLaunchKernelNV> requires <VK_NV_cuda_kernel_launch>" ); |
| # endif |
| |
| d.vkCmdCudaLaunchKernelNV( m_commandBuffer, reinterpret_cast<const VkCudaLaunchInfoNV *>( &launchInfo ) ); |
| } |
| # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| #endif /*VK_ENABLE_BETA_EXTENSIONS*/ |
| |
| #if defined( VK_USE_PLATFORM_METAL_EXT ) |
| //=== VK_EXT_metal_objects === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::exportMetalObjectsEXT( VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT * pMetalObjectsInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkExportMetalObjectsEXT( m_device, reinterpret_cast<VkExportMetalObjectsInfoEXT *>( pMetalObjectsInfo ) ); |
| } |
| |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT |
| Device::exportMetalObjectsEXT( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkExportMetalObjectsEXT && "Function <vkExportMetalObjectsEXT> requires <VK_EXT_metal_objects>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT metalObjectsInfo; |
| d.vkExportMetalObjectsEXT( m_device, reinterpret_cast<VkExportMetalObjectsInfoEXT *>( &metalObjectsInfo ) ); |
| |
| return metalObjectsInfo; |
| } |
| |
| template <typename X, typename Y, typename... Z, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> |
| Device::exportMetalObjectsEXT( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkExportMetalObjectsEXT && "Function <vkExportMetalObjectsEXT> requires <VK_EXT_metal_objects>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain; |
| VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT & metalObjectsInfo = structureChain.template get<VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT>(); |
| d.vkExportMetalObjectsEXT( m_device, reinterpret_cast<VkExportMetalObjectsInfoEXT *>( &metalObjectsInfo ) ); |
| |
| return structureChain; |
| } |
| # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| #endif /*VK_USE_PLATFORM_METAL_EXT*/ |
| |
| //=== VK_KHR_synchronization2 === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setEvent2KHR( VULKAN_HPP_NAMESPACE::Event event, |
| const VULKAN_HPP_NAMESPACE::DependencyInfo * pDependencyInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetEvent2KHR( m_commandBuffer, static_cast<VkEvent>( event ), reinterpret_cast<const VkDependencyInfo *>( pDependencyInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setEvent2KHR( VULKAN_HPP_NAMESPACE::Event event, |
| const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdSetEvent2KHR && "Function <vkCmdSetEvent2KHR> requires <VK_KHR_synchronization2> or <VK_VERSION_1_3>" ); |
| # endif |
| |
| d.vkCmdSetEvent2KHR( m_commandBuffer, static_cast<VkEvent>( event ), reinterpret_cast<const VkDependencyInfo *>( &dependencyInfo ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::resetEvent2KHR( VULKAN_HPP_NAMESPACE::Event event, |
| VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stageMask, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdResetEvent2KHR( m_commandBuffer, static_cast<VkEvent>( event ), static_cast<VkPipelineStageFlags2>( stageMask ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::waitEvents2KHR( uint32_t eventCount, |
| const VULKAN_HPP_NAMESPACE::Event * pEvents, |
| const VULKAN_HPP_NAMESPACE::DependencyInfo * pDependencyInfos, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdWaitEvents2KHR( |
| m_commandBuffer, eventCount, reinterpret_cast<const VkEvent *>( pEvents ), reinterpret_cast<const VkDependencyInfo *>( pDependencyInfos ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::waitEvents2KHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const & events, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DependencyInfo> const & dependencyInfos, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdWaitEvents2KHR && "Function <vkCmdWaitEvents2KHR> requires <VK_KHR_synchronization2> or <VK_VERSION_1_3>" ); |
| # endif |
| # ifdef VULKAN_HPP_NO_EXCEPTIONS |
| VULKAN_HPP_ASSERT( events.size() == dependencyInfos.size() ); |
| # else |
| if ( events.size() != dependencyInfos.size() ) |
| { |
| throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::waitEvents2KHR: events.size() != dependencyInfos.size()" ); |
| } |
| # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ |
| |
| d.vkCmdWaitEvents2KHR( m_commandBuffer, |
| events.size(), |
| reinterpret_cast<const VkEvent *>( events.data() ), |
| reinterpret_cast<const VkDependencyInfo *>( dependencyInfos.data() ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier2KHR( const VULKAN_HPP_NAMESPACE::DependencyInfo * pDependencyInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdPipelineBarrier2KHR( m_commandBuffer, reinterpret_cast<const VkDependencyInfo *>( pDependencyInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier2KHR( const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdPipelineBarrier2KHR && "Function <vkCmdPipelineBarrier2KHR> requires <VK_KHR_synchronization2> or <VK_VERSION_1_3>" ); |
| # endif |
| |
| d.vkCmdPipelineBarrier2KHR( m_commandBuffer, reinterpret_cast<const VkDependencyInfo *>( &dependencyInfo ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::writeTimestamp2KHR( VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stage, |
| VULKAN_HPP_NAMESPACE::QueryPool queryPool, |
| uint32_t query, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdWriteTimestamp2KHR( m_commandBuffer, static_cast<VkPipelineStageFlags2>( stage ), static_cast<VkQueryPool>( queryPool ), query ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Queue::submit2KHR( uint32_t submitCount, |
| const VULKAN_HPP_NAMESPACE::SubmitInfo2 * pSubmits, |
| VULKAN_HPP_NAMESPACE::Fence fence, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( |
| d.vkQueueSubmit2KHR( m_queue, submitCount, reinterpret_cast<const VkSubmitInfo2 *>( pSubmits ), static_cast<VkFence>( fence ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type Queue::submit2KHR( |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo2> const & submits, VULKAN_HPP_NAMESPACE::Fence fence, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkQueueSubmit2KHR && "Function <vkQueueSubmit2KHR> requires <VK_KHR_synchronization2> or <VK_VERSION_1_3>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkQueueSubmit2KHR( m_queue, submits.size(), reinterpret_cast<const VkSubmitInfo2 *>( submits.data() ), static_cast<VkFence>( fence ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::submit2KHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::writeBufferMarker2AMD( VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stage, |
| VULKAN_HPP_NAMESPACE::Buffer dstBuffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, |
| uint32_t marker, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdWriteBufferMarker2AMD( |
| m_commandBuffer, static_cast<VkPipelineStageFlags2>( stage ), static_cast<VkBuffer>( dstBuffer ), static_cast<VkDeviceSize>( dstOffset ), marker ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Queue::getCheckpointData2NV( uint32_t * pCheckpointDataCount, |
| VULKAN_HPP_NAMESPACE::CheckpointData2NV * pCheckpointData, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetQueueCheckpointData2NV( m_queue, pCheckpointDataCount, reinterpret_cast<VkCheckpointData2NV *>( pCheckpointData ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename CheckpointData2NVAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::CheckpointData2NV, CheckpointData2NVAllocator> |
| Queue::getCheckpointData2NV( Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetQueueCheckpointData2NV && "Function <vkGetQueueCheckpointData2NV> requires <VK_KHR_synchronization2>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::CheckpointData2NV, CheckpointData2NVAllocator> checkpointData; |
| uint32_t checkpointDataCount; |
| d.vkGetQueueCheckpointData2NV( m_queue, &checkpointDataCount, nullptr ); |
| checkpointData.resize( checkpointDataCount ); |
| d.vkGetQueueCheckpointData2NV( m_queue, &checkpointDataCount, reinterpret_cast<VkCheckpointData2NV *>( checkpointData.data() ) ); |
| |
| VULKAN_HPP_ASSERT( checkpointDataCount <= checkpointData.size() ); |
| if ( checkpointDataCount < checkpointData.size() ) |
| { |
| checkpointData.resize( checkpointDataCount ); |
| } |
| return checkpointData; |
| } |
| |
| template <typename CheckpointData2NVAllocator, |
| typename Dispatch, |
| typename std::enable_if<std::is_same<typename CheckpointData2NVAllocator::value_type, VULKAN_HPP_NAMESPACE::CheckpointData2NV>::value, int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::CheckpointData2NV, CheckpointData2NVAllocator> |
| Queue::getCheckpointData2NV( CheckpointData2NVAllocator & checkpointData2NVAllocator, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetQueueCheckpointData2NV && "Function <vkGetQueueCheckpointData2NV> requires <VK_KHR_synchronization2>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::CheckpointData2NV, CheckpointData2NVAllocator> checkpointData( checkpointData2NVAllocator ); |
| uint32_t checkpointDataCount; |
| d.vkGetQueueCheckpointData2NV( m_queue, &checkpointDataCount, nullptr ); |
| checkpointData.resize( checkpointDataCount ); |
| d.vkGetQueueCheckpointData2NV( m_queue, &checkpointDataCount, reinterpret_cast<VkCheckpointData2NV *>( checkpointData.data() ) ); |
| |
| VULKAN_HPP_ASSERT( checkpointDataCount <= checkpointData.size() ); |
| if ( checkpointDataCount < checkpointData.size() ) |
| { |
| checkpointData.resize( checkpointDataCount ); |
| } |
| return checkpointData; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_EXT_descriptor_buffer === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::getDescriptorSetLayoutSizeEXT( VULKAN_HPP_NAMESPACE::DescriptorSetLayout layout, |
| VULKAN_HPP_NAMESPACE::DeviceSize * pLayoutSizeInBytes, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetDescriptorSetLayoutSizeEXT( m_device, static_cast<VkDescriptorSetLayout>( layout ), reinterpret_cast<VkDeviceSize *>( pLayoutSizeInBytes ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceSize |
| Device::getDescriptorSetLayoutSizeEXT( VULKAN_HPP_NAMESPACE::DescriptorSetLayout layout, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetDescriptorSetLayoutSizeEXT && "Function <vkGetDescriptorSetLayoutSizeEXT> requires <VK_EXT_descriptor_buffer>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::DeviceSize layoutSizeInBytes; |
| d.vkGetDescriptorSetLayoutSizeEXT( m_device, static_cast<VkDescriptorSetLayout>( layout ), reinterpret_cast<VkDeviceSize *>( &layoutSizeInBytes ) ); |
| |
| return layoutSizeInBytes; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::getDescriptorSetLayoutBindingOffsetEXT( VULKAN_HPP_NAMESPACE::DescriptorSetLayout layout, |
| uint32_t binding, |
| VULKAN_HPP_NAMESPACE::DeviceSize * pOffset, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetDescriptorSetLayoutBindingOffsetEXT( m_device, static_cast<VkDescriptorSetLayout>( layout ), binding, reinterpret_cast<VkDeviceSize *>( pOffset ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceSize Device::getDescriptorSetLayoutBindingOffsetEXT( |
| VULKAN_HPP_NAMESPACE::DescriptorSetLayout layout, uint32_t binding, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetDescriptorSetLayoutBindingOffsetEXT && |
| "Function <vkGetDescriptorSetLayoutBindingOffsetEXT> requires <VK_EXT_descriptor_buffer>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::DeviceSize offset; |
| d.vkGetDescriptorSetLayoutBindingOffsetEXT( m_device, static_cast<VkDescriptorSetLayout>( layout ), binding, reinterpret_cast<VkDeviceSize *>( &offset ) ); |
| |
| return offset; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::getDescriptorEXT( const VULKAN_HPP_NAMESPACE::DescriptorGetInfoEXT * pDescriptorInfo, |
| size_t dataSize, |
| void * pDescriptor, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetDescriptorEXT( m_device, reinterpret_cast<const VkDescriptorGetInfoEXT *>( pDescriptorInfo ), dataSize, pDescriptor ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::getDescriptorEXT( const VULKAN_HPP_NAMESPACE::DescriptorGetInfoEXT & descriptorInfo, |
| size_t dataSize, |
| void * pDescriptor, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetDescriptorEXT && "Function <vkGetDescriptorEXT> requires <VK_EXT_descriptor_buffer>" ); |
| # endif |
| |
| d.vkGetDescriptorEXT( m_device, reinterpret_cast<const VkDescriptorGetInfoEXT *>( &descriptorInfo ), dataSize, pDescriptor ); |
| } |
| |
| template <typename DescriptorType, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DescriptorType Device::getDescriptorEXT( const VULKAN_HPP_NAMESPACE::DescriptorGetInfoEXT & descriptorInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetDescriptorEXT && "Function <vkGetDescriptorEXT> requires <VK_EXT_descriptor_buffer>" ); |
| # endif |
| |
| DescriptorType descriptor; |
| d.vkGetDescriptorEXT( |
| m_device, reinterpret_cast<const VkDescriptorGetInfoEXT *>( &descriptorInfo ), sizeof( DescriptorType ), reinterpret_cast<void *>( &descriptor ) ); |
| |
| return descriptor; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorBuffersEXT( uint32_t bufferCount, |
| const VULKAN_HPP_NAMESPACE::DescriptorBufferBindingInfoEXT * pBindingInfos, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdBindDescriptorBuffersEXT( m_commandBuffer, bufferCount, reinterpret_cast<const VkDescriptorBufferBindingInfoEXT *>( pBindingInfos ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void |
| CommandBuffer::bindDescriptorBuffersEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorBufferBindingInfoEXT> const & bindingInfos, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdBindDescriptorBuffersEXT && "Function <vkCmdBindDescriptorBuffersEXT> requires <VK_EXT_descriptor_buffer>" ); |
| # endif |
| |
| d.vkCmdBindDescriptorBuffersEXT( m_commandBuffer, bindingInfos.size(), reinterpret_cast<const VkDescriptorBufferBindingInfoEXT *>( bindingInfos.data() ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setDescriptorBufferOffsetsEXT( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, |
| VULKAN_HPP_NAMESPACE::PipelineLayout layout, |
| uint32_t firstSet, |
| uint32_t setCount, |
| const uint32_t * pBufferIndices, |
| const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetDescriptorBufferOffsetsEXT( m_commandBuffer, |
| static_cast<VkPipelineBindPoint>( pipelineBindPoint ), |
| static_cast<VkPipelineLayout>( layout ), |
| firstSet, |
| setCount, |
| pBufferIndices, |
| reinterpret_cast<const VkDeviceSize *>( pOffsets ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setDescriptorBufferOffsetsEXT( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, |
| VULKAN_HPP_NAMESPACE::PipelineLayout layout, |
| uint32_t firstSet, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t> const & bufferIndices, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdSetDescriptorBufferOffsetsEXT && "Function <vkCmdSetDescriptorBufferOffsetsEXT> requires <VK_EXT_descriptor_buffer>" ); |
| # endif |
| # ifdef VULKAN_HPP_NO_EXCEPTIONS |
| VULKAN_HPP_ASSERT( bufferIndices.size() == offsets.size() ); |
| # else |
| if ( bufferIndices.size() != offsets.size() ) |
| { |
| throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::setDescriptorBufferOffsetsEXT: bufferIndices.size() != offsets.size()" ); |
| } |
| # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ |
| |
| d.vkCmdSetDescriptorBufferOffsetsEXT( m_commandBuffer, |
| static_cast<VkPipelineBindPoint>( pipelineBindPoint ), |
| static_cast<VkPipelineLayout>( layout ), |
| firstSet, |
| bufferIndices.size(), |
| bufferIndices.data(), |
| reinterpret_cast<const VkDeviceSize *>( offsets.data() ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorBufferEmbeddedSamplersEXT( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, |
| VULKAN_HPP_NAMESPACE::PipelineLayout layout, |
| uint32_t set, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdBindDescriptorBufferEmbeddedSamplersEXT( |
| m_commandBuffer, static_cast<VkPipelineBindPoint>( pipelineBindPoint ), static_cast<VkPipelineLayout>( layout ), set ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getBufferOpaqueCaptureDescriptorDataEXT( |
| const VULKAN_HPP_NAMESPACE::BufferCaptureDescriptorDataInfoEXT * pInfo, void * pData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( |
| d.vkGetBufferOpaqueCaptureDescriptorDataEXT( m_device, reinterpret_cast<const VkBufferCaptureDescriptorDataInfoEXT *>( pInfo ), pData ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename DataType, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<DataType>::type |
| Device::getBufferOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::BufferCaptureDescriptorDataInfoEXT & info, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetBufferOpaqueCaptureDescriptorDataEXT && |
| "Function <vkGetBufferOpaqueCaptureDescriptorDataEXT> requires <VK_EXT_descriptor_buffer>" ); |
| # endif |
| |
| DataType data; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetBufferOpaqueCaptureDescriptorDataEXT( m_device, reinterpret_cast<const VkBufferCaptureDescriptorDataInfoEXT *>( &info ), &data ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getBufferOpaqueCaptureDescriptorDataEXT" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getImageOpaqueCaptureDescriptorDataEXT( |
| const VULKAN_HPP_NAMESPACE::ImageCaptureDescriptorDataInfoEXT * pInfo, void * pData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( |
| d.vkGetImageOpaqueCaptureDescriptorDataEXT( m_device, reinterpret_cast<const VkImageCaptureDescriptorDataInfoEXT *>( pInfo ), pData ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename DataType, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<DataType>::type |
| Device::getImageOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::ImageCaptureDescriptorDataInfoEXT & info, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetImageOpaqueCaptureDescriptorDataEXT && |
| "Function <vkGetImageOpaqueCaptureDescriptorDataEXT> requires <VK_EXT_descriptor_buffer>" ); |
| # endif |
| |
| DataType data; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetImageOpaqueCaptureDescriptorDataEXT( m_device, reinterpret_cast<const VkImageCaptureDescriptorDataInfoEXT *>( &info ), &data ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getImageOpaqueCaptureDescriptorDataEXT" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getImageViewOpaqueCaptureDescriptorDataEXT( |
| const VULKAN_HPP_NAMESPACE::ImageViewCaptureDescriptorDataInfoEXT * pInfo, void * pData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( |
| d.vkGetImageViewOpaqueCaptureDescriptorDataEXT( m_device, reinterpret_cast<const VkImageViewCaptureDescriptorDataInfoEXT *>( pInfo ), pData ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename DataType, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<DataType>::type |
| Device::getImageViewOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::ImageViewCaptureDescriptorDataInfoEXT & info, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetImageViewOpaqueCaptureDescriptorDataEXT && |
| "Function <vkGetImageViewOpaqueCaptureDescriptorDataEXT> requires <VK_EXT_descriptor_buffer>" ); |
| # endif |
| |
| DataType data; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetImageViewOpaqueCaptureDescriptorDataEXT( m_device, reinterpret_cast<const VkImageViewCaptureDescriptorDataInfoEXT *>( &info ), &data ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getImageViewOpaqueCaptureDescriptorDataEXT" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSamplerOpaqueCaptureDescriptorDataEXT( |
| const VULKAN_HPP_NAMESPACE::SamplerCaptureDescriptorDataInfoEXT * pInfo, void * pData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( |
| d.vkGetSamplerOpaqueCaptureDescriptorDataEXT( m_device, reinterpret_cast<const VkSamplerCaptureDescriptorDataInfoEXT *>( pInfo ), pData ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename DataType, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<DataType>::type |
| Device::getSamplerOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::SamplerCaptureDescriptorDataInfoEXT & info, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetSamplerOpaqueCaptureDescriptorDataEXT && |
| "Function <vkGetSamplerOpaqueCaptureDescriptorDataEXT> requires <VK_EXT_descriptor_buffer>" ); |
| # endif |
| |
| DataType data; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetSamplerOpaqueCaptureDescriptorDataEXT( m_device, reinterpret_cast<const VkSamplerCaptureDescriptorDataInfoEXT *>( &info ), &data ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSamplerOpaqueCaptureDescriptorDataEXT" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getAccelerationStructureOpaqueCaptureDescriptorDataEXT( |
| const VULKAN_HPP_NAMESPACE::AccelerationStructureCaptureDescriptorDataInfoEXT * pInfo, void * pData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT( |
| m_device, reinterpret_cast<const VkAccelerationStructureCaptureDescriptorDataInfoEXT *>( pInfo ), pData ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename DataType, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<DataType>::type |
| Device::getAccelerationStructureOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::AccelerationStructureCaptureDescriptorDataInfoEXT & info, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT && |
| "Function <vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT> requires <VK_EXT_descriptor_buffer>" ); |
| # endif |
| |
| DataType data; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT( |
| m_device, reinterpret_cast<const VkAccelerationStructureCaptureDescriptorDataInfoEXT *>( &info ), &data ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getAccelerationStructureOpaqueCaptureDescriptorDataEXT" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_NV_fragment_shading_rate_enums === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setFragmentShadingRateEnumNV( VULKAN_HPP_NAMESPACE::FragmentShadingRateNV shadingRate, |
| const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2], |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetFragmentShadingRateEnumNV( |
| m_commandBuffer, static_cast<VkFragmentShadingRateNV>( shadingRate ), reinterpret_cast<const VkFragmentShadingRateCombinerOpKHR *>( combinerOps ) ); |
| } |
| |
| //=== VK_EXT_mesh_shader === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void |
| CommandBuffer::drawMeshTasksEXT( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdDrawMeshTasksEXT( m_commandBuffer, groupCountX, groupCountY, groupCountZ ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectEXT( VULKAN_HPP_NAMESPACE::Buffer buffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize offset, |
| uint32_t drawCount, |
| uint32_t stride, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdDrawMeshTasksIndirectEXT( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), drawCount, stride ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectCountEXT( VULKAN_HPP_NAMESPACE::Buffer buffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize offset, |
| VULKAN_HPP_NAMESPACE::Buffer countBuffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, |
| uint32_t maxDrawCount, |
| uint32_t stride, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdDrawMeshTasksIndirectCountEXT( m_commandBuffer, |
| static_cast<VkBuffer>( buffer ), |
| static_cast<VkDeviceSize>( offset ), |
| static_cast<VkBuffer>( countBuffer ), |
| static_cast<VkDeviceSize>( countBufferOffset ), |
| maxDrawCount, |
| stride ); |
| } |
| |
| //=== VK_KHR_copy_commands2 === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::copyBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 * pCopyBufferInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdCopyBuffer2KHR( m_commandBuffer, reinterpret_cast<const VkCopyBufferInfo2 *>( pCopyBufferInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::copyBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 & copyBufferInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdCopyBuffer2KHR && "Function <vkCmdCopyBuffer2KHR> requires <VK_KHR_copy_commands2> or <VK_VERSION_1_3>" ); |
| # endif |
| |
| d.vkCmdCopyBuffer2KHR( m_commandBuffer, reinterpret_cast<const VkCopyBufferInfo2 *>( ©BufferInfo ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::copyImage2KHR( const VULKAN_HPP_NAMESPACE::CopyImageInfo2 * pCopyImageInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdCopyImage2KHR( m_commandBuffer, reinterpret_cast<const VkCopyImageInfo2 *>( pCopyImageInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::copyImage2KHR( const VULKAN_HPP_NAMESPACE::CopyImageInfo2 & copyImageInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdCopyImage2KHR && "Function <vkCmdCopyImage2KHR> requires <VK_KHR_copy_commands2> or <VK_VERSION_1_3>" ); |
| # endif |
| |
| d.vkCmdCopyImage2KHR( m_commandBuffer, reinterpret_cast<const VkCopyImageInfo2 *>( ©ImageInfo ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 * pCopyBufferToImageInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdCopyBufferToImage2KHR( m_commandBuffer, reinterpret_cast<const VkCopyBufferToImageInfo2 *>( pCopyBufferToImageInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 & copyBufferToImageInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdCopyBufferToImage2KHR && "Function <vkCmdCopyBufferToImage2KHR> requires <VK_KHR_copy_commands2> or <VK_VERSION_1_3>" ); |
| # endif |
| |
| d.vkCmdCopyBufferToImage2KHR( m_commandBuffer, reinterpret_cast<const VkCopyBufferToImageInfo2 *>( ©BufferToImageInfo ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 * pCopyImageToBufferInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdCopyImageToBuffer2KHR( m_commandBuffer, reinterpret_cast<const VkCopyImageToBufferInfo2 *>( pCopyImageToBufferInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 & copyImageToBufferInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdCopyImageToBuffer2KHR && "Function <vkCmdCopyImageToBuffer2KHR> requires <VK_KHR_copy_commands2> or <VK_VERSION_1_3>" ); |
| # endif |
| |
| d.vkCmdCopyImageToBuffer2KHR( m_commandBuffer, reinterpret_cast<const VkCopyImageToBufferInfo2 *>( ©ImageToBufferInfo ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::blitImage2KHR( const VULKAN_HPP_NAMESPACE::BlitImageInfo2 * pBlitImageInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdBlitImage2KHR( m_commandBuffer, reinterpret_cast<const VkBlitImageInfo2 *>( pBlitImageInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::blitImage2KHR( const VULKAN_HPP_NAMESPACE::BlitImageInfo2 & blitImageInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdBlitImage2KHR && "Function <vkCmdBlitImage2KHR> requires <VK_KHR_copy_commands2> or <VK_VERSION_1_3>" ); |
| # endif |
| |
| d.vkCmdBlitImage2KHR( m_commandBuffer, reinterpret_cast<const VkBlitImageInfo2 *>( &blitImageInfo ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::resolveImage2KHR( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 * pResolveImageInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdResolveImage2KHR( m_commandBuffer, reinterpret_cast<const VkResolveImageInfo2 *>( pResolveImageInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::resolveImage2KHR( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 & resolveImageInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdResolveImage2KHR && "Function <vkCmdResolveImage2KHR> requires <VK_KHR_copy_commands2> or <VK_VERSION_1_3>" ); |
| # endif |
| |
| d.vkCmdResolveImage2KHR( m_commandBuffer, reinterpret_cast<const VkResolveImageInfo2 *>( &resolveImageInfo ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_EXT_device_fault === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getFaultInfoEXT( VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT * pFaultCounts, |
| VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT * pFaultInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetDeviceFaultInfoEXT( |
| m_device, reinterpret_cast<VkDeviceFaultCountsEXT *>( pFaultCounts ), reinterpret_cast<VkDeviceFaultInfoEXT *>( pFaultInfo ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE |
| typename ResultValueType<std::pair<VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT, VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT>>::type |
| Device::getFaultInfoEXT( Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetDeviceFaultInfoEXT && "Function <vkGetDeviceFaultInfoEXT> requires <VK_EXT_device_fault>" ); |
| # endif |
| |
| std::pair<VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT, VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT> data_; |
| VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT & faultCounts = data_.first; |
| VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT & faultInfo = data_.second; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = |
| static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetDeviceFaultInfoEXT( m_device, reinterpret_cast<VkDeviceFaultCountsEXT *>( &faultCounts ), nullptr ) ); |
| if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) |
| { |
| std::free( faultInfo.pAddressInfos ); |
| if ( faultCounts.addressInfoCount ) |
| { |
| faultInfo.pAddressInfos = reinterpret_cast<VULKAN_HPP_NAMESPACE::DeviceFaultAddressInfoEXT *>( |
| std::malloc( faultCounts.addressInfoCount * sizeof( VULKAN_HPP_NAMESPACE::DeviceFaultAddressInfoEXT ) ) ); |
| } |
| std::free( faultInfo.pVendorInfos ); |
| if ( faultCounts.vendorInfoCount ) |
| { |
| faultInfo.pVendorInfos = reinterpret_cast<VULKAN_HPP_NAMESPACE::DeviceFaultVendorInfoEXT *>( |
| std::malloc( faultCounts.vendorInfoCount * sizeof( VULKAN_HPP_NAMESPACE::DeviceFaultVendorInfoEXT ) ) ); |
| } |
| std::free( faultInfo.pVendorBinaryData ); |
| if ( faultCounts.vendorBinarySize ) |
| { |
| faultInfo.pVendorBinaryData = std::malloc( faultCounts.vendorBinarySize ); |
| } |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetDeviceFaultInfoEXT( |
| m_device, reinterpret_cast<VkDeviceFaultCountsEXT *>( &faultCounts ), reinterpret_cast<VkDeviceFaultInfoEXT *>( &faultInfo ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( |
| result, VULKAN_HPP_NAMESPACE_STRING "::Device::getFaultInfoEXT", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eIncomplete } ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data_ ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| #if defined( VK_USE_PLATFORM_WIN32_KHR ) |
| //=== VK_NV_acquire_winrt_display === |
| |
| # 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 |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| 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 |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkAcquireWinrtDisplayNV && "Function <vkAcquireWinrtDisplayNV> requires <VK_NV_acquire_winrt_display>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = |
| static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkAcquireWinrtDisplayNV( m_physicalDevice, static_cast<VkDisplayKHR>( display ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::acquireWinrtDisplayNV" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); |
| } |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| 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 |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| 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 VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayKHR>::type |
| PhysicalDevice::getWinrtDisplayNV( uint32_t deviceRelativeId, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetWinrtDisplayNV && "Function <vkGetWinrtDisplayNV> requires <VK_NV_acquire_winrt_display>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::DisplayKHR display; |
| VULKAN_HPP_NAMESPACE::Result result = |
| static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetWinrtDisplayNV( m_physicalDevice, deviceRelativeId, reinterpret_cast<VkDisplayKHR *>( &display ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getWinrtDisplayNV" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( display ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>>::type |
| PhysicalDevice::getWinrtDisplayNVUnique( uint32_t deviceRelativeId, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetWinrtDisplayNV && "Function <vkGetWinrtDisplayNV> requires <VK_NV_acquire_winrt_display>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::DisplayKHR display; |
| VULKAN_HPP_NAMESPACE::Result result = |
| static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetWinrtDisplayNV( m_physicalDevice, deviceRelativeId, reinterpret_cast<VkDisplayKHR *>( &display ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getWinrtDisplayNVUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>( display, ObjectRelease<PhysicalDevice, Dispatch>( *this, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| #endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| #if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) |
| //=== VK_EXT_directfb_surface === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createDirectFBSurfaceEXT( const VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateDirectFBSurfaceEXT( m_instance, |
| reinterpret_cast<const VkDirectFBSurfaceCreateInfoEXT *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) ); |
| } |
| |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type |
| Instance::createDirectFBSurfaceEXT( const VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateDirectFBSurfaceEXT && "Function <vkCreateDirectFBSurfaceEXT> requires <VK_EXT_directfb_surface>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateDirectFBSurfaceEXT( |
| m_instance, |
| reinterpret_cast<const VkDirectFBSurfaceCreateInfoEXT *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkSurfaceKHR *>( &surface ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDirectFBSurfaceEXT" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( surface ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type |
| Instance::createDirectFBSurfaceEXTUnique( const VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateDirectFBSurfaceEXT && "Function <vkCreateDirectFBSurfaceEXT> requires <VK_EXT_directfb_surface>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateDirectFBSurfaceEXT( |
| m_instance, |
| reinterpret_cast<const VkDirectFBSurfaceCreateInfoEXT *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkSurfaceKHR *>( &surface ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDirectFBSurfaceEXTUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>( surface, ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE Bool32 PhysicalDevice::getDirectFBPresentationSupportEXT( uint32_t queueFamilyIndex, |
| IDirectFB * dfb, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Bool32>( d.vkGetPhysicalDeviceDirectFBPresentationSupportEXT( m_physicalDevice, queueFamilyIndex, dfb ) ); |
| } |
| |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Bool32 |
| PhysicalDevice::getDirectFBPresentationSupportEXT( uint32_t queueFamilyIndex, IDirectFB & dfb, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceDirectFBPresentationSupportEXT && |
| "Function <vkGetPhysicalDeviceDirectFBPresentationSupportEXT> requires <VK_EXT_directfb_surface>" ); |
| # endif |
| |
| VkBool32 result = d.vkGetPhysicalDeviceDirectFBPresentationSupportEXT( m_physicalDevice, queueFamilyIndex, &dfb ); |
| |
| return static_cast<VULKAN_HPP_NAMESPACE::Bool32>( result ); |
| } |
| # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| #endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ |
| |
| //=== VK_EXT_vertex_input_dynamic_state === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setVertexInputEXT( uint32_t vertexBindingDescriptionCount, |
| const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT * pVertexBindingDescriptions, |
| uint32_t vertexAttributeDescriptionCount, |
| const VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT * pVertexAttributeDescriptions, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetVertexInputEXT( m_commandBuffer, |
| vertexBindingDescriptionCount, |
| reinterpret_cast<const VkVertexInputBindingDescription2EXT *>( pVertexBindingDescriptions ), |
| vertexAttributeDescriptionCount, |
| reinterpret_cast<const VkVertexInputAttributeDescription2EXT *>( pVertexAttributeDescriptions ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setVertexInputEXT( |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT> const & vertexBindingDescriptions, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT> const & vertexAttributeDescriptions, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdSetVertexInputEXT && "Function <vkCmdSetVertexInputEXT> requires <VK_EXT_shader_object> or <VK_EXT_vertex_input_dynamic_state>" ); |
| # endif |
| |
| d.vkCmdSetVertexInputEXT( m_commandBuffer, |
| vertexBindingDescriptions.size(), |
| reinterpret_cast<const VkVertexInputBindingDescription2EXT *>( vertexBindingDescriptions.data() ), |
| vertexAttributeDescriptions.size(), |
| reinterpret_cast<const VkVertexInputAttributeDescription2EXT *>( vertexAttributeDescriptions.data() ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| #if defined( VK_USE_PLATFORM_FUCHSIA ) |
| //=== VK_FUCHSIA_external_memory === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| Device::getMemoryZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo, |
| zx_handle_t * pZirconHandle, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( |
| d.vkGetMemoryZirconHandleFUCHSIA( m_device, reinterpret_cast<const VkMemoryGetZirconHandleInfoFUCHSIA *>( pGetZirconHandleInfo ), pZirconHandle ) ); |
| } |
| |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<zx_handle_t>::type |
| Device::getMemoryZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA & getZirconHandleInfo, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetMemoryZirconHandleFUCHSIA && "Function <vkGetMemoryZirconHandleFUCHSIA> requires <VK_FUCHSIA_external_memory>" ); |
| # endif |
| |
| zx_handle_t zirconHandle; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetMemoryZirconHandleFUCHSIA( m_device, reinterpret_cast<const VkMemoryGetZirconHandleInfoFUCHSIA *>( &getZirconHandleInfo ), &zirconHandle ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryZirconHandleFUCHSIA" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( zirconHandle ) ); |
| } |
| # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| Device::getMemoryZirconHandlePropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, |
| zx_handle_t zirconHandle, |
| VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA * pMemoryZirconHandleProperties, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( |
| d.vkGetMemoryZirconHandlePropertiesFUCHSIA( m_device, |
| static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ), |
| zirconHandle, |
| reinterpret_cast<VkMemoryZirconHandlePropertiesFUCHSIA *>( pMemoryZirconHandleProperties ) ) ); |
| } |
| |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA>::type |
| Device::getMemoryZirconHandlePropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, |
| zx_handle_t zirconHandle, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetMemoryZirconHandlePropertiesFUCHSIA && |
| "Function <vkGetMemoryZirconHandlePropertiesFUCHSIA> requires <VK_FUCHSIA_external_memory>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA memoryZirconHandleProperties; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetMemoryZirconHandlePropertiesFUCHSIA( m_device, |
| static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ), |
| zirconHandle, |
| reinterpret_cast<VkMemoryZirconHandlePropertiesFUCHSIA *>( &memoryZirconHandleProperties ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryZirconHandlePropertiesFUCHSIA" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( memoryZirconHandleProperties ) ); |
| } |
| # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| #endif /*VK_USE_PLATFORM_FUCHSIA*/ |
| |
| #if defined( VK_USE_PLATFORM_FUCHSIA ) |
| //=== VK_FUCHSIA_external_semaphore === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::importSemaphoreZirconHandleFUCHSIA( |
| const VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA * pImportSemaphoreZirconHandleInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkImportSemaphoreZirconHandleFUCHSIA( |
| m_device, reinterpret_cast<const VkImportSemaphoreZirconHandleInfoFUCHSIA *>( pImportSemaphoreZirconHandleInfo ) ) ); |
| } |
| |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type |
| Device::importSemaphoreZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA & importSemaphoreZirconHandleInfo, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkImportSemaphoreZirconHandleFUCHSIA && "Function <vkImportSemaphoreZirconHandleFUCHSIA> requires <VK_FUCHSIA_external_semaphore>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkImportSemaphoreZirconHandleFUCHSIA( |
| m_device, reinterpret_cast<const VkImportSemaphoreZirconHandleInfoFUCHSIA *>( &importSemaphoreZirconHandleInfo ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::importSemaphoreZirconHandleFUCHSIA" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); |
| } |
| # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| Device::getSemaphoreZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo, |
| zx_handle_t * pZirconHandle, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( |
| d.vkGetSemaphoreZirconHandleFUCHSIA( m_device, reinterpret_cast<const VkSemaphoreGetZirconHandleInfoFUCHSIA *>( pGetZirconHandleInfo ), pZirconHandle ) ); |
| } |
| |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<zx_handle_t>::type |
| Device::getSemaphoreZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA & getZirconHandleInfo, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetSemaphoreZirconHandleFUCHSIA && "Function <vkGetSemaphoreZirconHandleFUCHSIA> requires <VK_FUCHSIA_external_semaphore>" ); |
| # endif |
| |
| zx_handle_t zirconHandle; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetSemaphoreZirconHandleFUCHSIA( m_device, reinterpret_cast<const VkSemaphoreGetZirconHandleInfoFUCHSIA *>( &getZirconHandleInfo ), &zirconHandle ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreZirconHandleFUCHSIA" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( zirconHandle ) ); |
| } |
| # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| #endif /*VK_USE_PLATFORM_FUCHSIA*/ |
| |
| #if defined( VK_USE_PLATFORM_FUCHSIA ) |
| //=== VK_FUCHSIA_buffer_collection === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| Device::createBufferCollectionFUCHSIA( const VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA * pCollection, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateBufferCollectionFUCHSIA( m_device, |
| reinterpret_cast<const VkBufferCollectionCreateInfoFUCHSIA *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkBufferCollectionFUCHSIA *>( pCollection ) ) ); |
| } |
| |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA>::type |
| Device::createBufferCollectionFUCHSIA( const VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateBufferCollectionFUCHSIA && "Function <vkCreateBufferCollectionFUCHSIA> requires <VK_FUCHSIA_buffer_collection>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateBufferCollectionFUCHSIA( |
| m_device, |
| reinterpret_cast<const VkBufferCollectionCreateInfoFUCHSIA *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkBufferCollectionFUCHSIA *>( &collection ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createBufferCollectionFUCHSIA" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( collection ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA, Dispatch>>::type |
| Device::createBufferCollectionFUCHSIAUnique( const VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateBufferCollectionFUCHSIA && "Function <vkCreateBufferCollectionFUCHSIA> requires <VK_FUCHSIA_buffer_collection>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateBufferCollectionFUCHSIA( |
| m_device, |
| reinterpret_cast<const VkBufferCollectionCreateInfoFUCHSIA *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkBufferCollectionFUCHSIA *>( &collection ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createBufferCollectionFUCHSIAUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA, Dispatch>( collection, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| Device::setBufferCollectionImageConstraintsFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection, |
| const VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA * pImageConstraintsInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkSetBufferCollectionImageConstraintsFUCHSIA( |
| m_device, static_cast<VkBufferCollectionFUCHSIA>( collection ), reinterpret_cast<const VkImageConstraintsInfoFUCHSIA *>( pImageConstraintsInfo ) ) ); |
| } |
| |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type |
| Device::setBufferCollectionImageConstraintsFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection, |
| const VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA & imageConstraintsInfo, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkSetBufferCollectionImageConstraintsFUCHSIA && |
| "Function <vkSetBufferCollectionImageConstraintsFUCHSIA> requires <VK_FUCHSIA_buffer_collection>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkSetBufferCollectionImageConstraintsFUCHSIA( |
| m_device, static_cast<VkBufferCollectionFUCHSIA>( collection ), reinterpret_cast<const VkImageConstraintsInfoFUCHSIA *>( &imageConstraintsInfo ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setBufferCollectionImageConstraintsFUCHSIA" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); |
| } |
| # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| Device::setBufferCollectionBufferConstraintsFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection, |
| const VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA * pBufferConstraintsInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkSetBufferCollectionBufferConstraintsFUCHSIA( |
| m_device, static_cast<VkBufferCollectionFUCHSIA>( collection ), reinterpret_cast<const VkBufferConstraintsInfoFUCHSIA *>( pBufferConstraintsInfo ) ) ); |
| } |
| |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type |
| Device::setBufferCollectionBufferConstraintsFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection, |
| const VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA & bufferConstraintsInfo, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkSetBufferCollectionBufferConstraintsFUCHSIA && |
| "Function <vkSetBufferCollectionBufferConstraintsFUCHSIA> requires <VK_FUCHSIA_buffer_collection>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkSetBufferCollectionBufferConstraintsFUCHSIA( |
| m_device, static_cast<VkBufferCollectionFUCHSIA>( collection ), reinterpret_cast<const VkBufferConstraintsInfoFUCHSIA *>( &bufferConstraintsInfo ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setBufferCollectionBufferConstraintsFUCHSIA" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); |
| } |
| # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyBufferCollectionFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyBufferCollectionFUCHSIA( |
| m_device, static_cast<VkBufferCollectionFUCHSIA>( collection ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyBufferCollectionFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyBufferCollectionFUCHSIA && "Function <vkDestroyBufferCollectionFUCHSIA> requires <VK_FUCHSIA_buffer_collection>" ); |
| # endif |
| |
| d.vkDestroyBufferCollectionFUCHSIA( |
| m_device, |
| static_cast<VkBufferCollectionFUCHSIA>( collection ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyBufferCollectionFUCHSIA( |
| m_device, static_cast<VkBufferCollectionFUCHSIA>( collection ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyBufferCollectionFUCHSIA && "Function <vkDestroyBufferCollectionFUCHSIA> requires <VK_FUCHSIA_buffer_collection>" ); |
| # endif |
| |
| d.vkDestroyBufferCollectionFUCHSIA( |
| m_device, |
| static_cast<VkBufferCollectionFUCHSIA>( collection ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| Device::getBufferCollectionPropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection, |
| VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA * pProperties, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetBufferCollectionPropertiesFUCHSIA( |
| m_device, static_cast<VkBufferCollectionFUCHSIA>( collection ), reinterpret_cast<VkBufferCollectionPropertiesFUCHSIA *>( pProperties ) ) ); |
| } |
| |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA>::type |
| Device::getBufferCollectionPropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetBufferCollectionPropertiesFUCHSIA && |
| "Function <vkGetBufferCollectionPropertiesFUCHSIA> requires <VK_FUCHSIA_buffer_collection>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA properties; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetBufferCollectionPropertiesFUCHSIA( |
| m_device, static_cast<VkBufferCollectionFUCHSIA>( collection ), reinterpret_cast<VkBufferCollectionPropertiesFUCHSIA *>( &properties ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getBufferCollectionPropertiesFUCHSIA" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); |
| } |
| # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| #endif /*VK_USE_PLATFORM_FUCHSIA*/ |
| |
| //=== VK_HUAWEI_subpass_shading === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSubpassShadingMaxWorkgroupSizeHUAWEI( VULKAN_HPP_NAMESPACE::RenderPass renderpass, |
| VULKAN_HPP_NAMESPACE::Extent2D * pMaxWorkgroupSize, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( |
| m_device, static_cast<VkRenderPass>( renderpass ), reinterpret_cast<VkExtent2D *>( pMaxWorkgroupSize ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::Extent2D>::type |
| Device::getSubpassShadingMaxWorkgroupSizeHUAWEI( VULKAN_HPP_NAMESPACE::RenderPass renderpass, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI && |
| "Function <vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI> requires <VK_HUAWEI_subpass_shading>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Extent2D maxWorkgroupSize; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( |
| m_device, static_cast<VkRenderPass>( renderpass ), reinterpret_cast<VkExtent2D *>( &maxWorkgroupSize ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSubpassShadingMaxWorkgroupSizeHUAWEI" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( maxWorkgroupSize ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::subpassShadingHUAWEI( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSubpassShadingHUAWEI( m_commandBuffer ); |
| } |
| |
| //=== VK_HUAWEI_invocation_mask === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::bindInvocationMaskHUAWEI( VULKAN_HPP_NAMESPACE::ImageView imageView, |
| VULKAN_HPP_NAMESPACE::ImageLayout imageLayout, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdBindInvocationMaskHUAWEI( m_commandBuffer, static_cast<VkImageView>( imageView ), static_cast<VkImageLayout>( imageLayout ) ); |
| } |
| |
| //=== VK_NV_external_memory_rdma === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| Device::getMemoryRemoteAddressNV( const VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV * pMemoryGetRemoteAddressInfo, |
| VULKAN_HPP_NAMESPACE::RemoteAddressNV * pAddress, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetMemoryRemoteAddressNV( |
| m_device, reinterpret_cast<const VkMemoryGetRemoteAddressInfoNV *>( pMemoryGetRemoteAddressInfo ), reinterpret_cast<VkRemoteAddressNV *>( pAddress ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::RemoteAddressNV>::type |
| Device::getMemoryRemoteAddressNV( const VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV & memoryGetRemoteAddressInfo, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetMemoryRemoteAddressNV && "Function <vkGetMemoryRemoteAddressNV> requires <VK_NV_external_memory_rdma>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::RemoteAddressNV address; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetMemoryRemoteAddressNV( |
| m_device, reinterpret_cast<const VkMemoryGetRemoteAddressInfoNV *>( &memoryGetRemoteAddressInfo ), reinterpret_cast<VkRemoteAddressNV *>( &address ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryRemoteAddressNV" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( address ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_EXT_pipeline_properties === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getPipelinePropertiesEXT( const VULKAN_HPP_NAMESPACE::PipelineInfoEXT * pPipelineInfo, |
| VULKAN_HPP_NAMESPACE::BaseOutStructure * pPipelineProperties, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetPipelinePropertiesEXT( |
| m_device, reinterpret_cast<const VkPipelineInfoEXT *>( pPipelineInfo ), reinterpret_cast<VkBaseOutStructure *>( pPipelineProperties ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::BaseOutStructure>::type |
| Device::getPipelinePropertiesEXT( const VULKAN_HPP_NAMESPACE::PipelineInfoEXT & pipelineInfo, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPipelinePropertiesEXT && "Function <vkGetPipelinePropertiesEXT> requires <VK_EXT_pipeline_properties>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::BaseOutStructure pipelineProperties; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPipelinePropertiesEXT( |
| m_device, reinterpret_cast<const VkPipelineInfoEXT *>( &pipelineInfo ), reinterpret_cast<VkBaseOutStructure *>( &pipelineProperties ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelinePropertiesEXT" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( pipelineProperties ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_EXT_extended_dynamic_state2 === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setPatchControlPointsEXT( uint32_t patchControlPoints, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetPatchControlPointsEXT( m_commandBuffer, patchControlPoints ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setRasterizerDiscardEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetRasterizerDiscardEnableEXT( m_commandBuffer, static_cast<VkBool32>( rasterizerDiscardEnable ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setDepthBiasEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetDepthBiasEnableEXT( m_commandBuffer, static_cast<VkBool32>( depthBiasEnable ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setLogicOpEXT( VULKAN_HPP_NAMESPACE::LogicOp logicOp, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetLogicOpEXT( m_commandBuffer, static_cast<VkLogicOp>( logicOp ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setPrimitiveRestartEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetPrimitiveRestartEnableEXT( m_commandBuffer, static_cast<VkBool32>( primitiveRestartEnable ) ); |
| } |
| |
| #if defined( VK_USE_PLATFORM_SCREEN_QNX ) |
| //=== VK_QNX_screen_surface === |
| |
| 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 |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| 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 VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type |
| Instance::createScreenSurfaceQNX( const VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateScreenSurfaceQNX && "Function <vkCreateScreenSurfaceQNX> requires <VK_QNX_screen_surface>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::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 ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createScreenSurfaceQNX" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( surface ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type |
| Instance::createScreenSurfaceQNXUnique( const VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateScreenSurfaceQNX && "Function <vkCreateScreenSurfaceQNX> requires <VK_QNX_screen_surface>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::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 ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createScreenSurfaceQNXUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>( surface, ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| # endif /* 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 |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Bool32>( d.vkGetPhysicalDeviceScreenPresentationSupportQNX( m_physicalDevice, queueFamilyIndex, window ) ); |
| } |
| |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Bool32 |
| PhysicalDevice::getScreenPresentationSupportQNX( uint32_t queueFamilyIndex, struct _screen_window & window, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceScreenPresentationSupportQNX && |
| "Function <vkGetPhysicalDeviceScreenPresentationSupportQNX> requires <VK_QNX_screen_surface>" ); |
| # endif |
| |
| VkBool32 result = d.vkGetPhysicalDeviceScreenPresentationSupportQNX( m_physicalDevice, queueFamilyIndex, &window ); |
| |
| return static_cast<VULKAN_HPP_NAMESPACE::Bool32>( result ); |
| } |
| # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| #endif /*VK_USE_PLATFORM_SCREEN_QNX*/ |
| |
| //=== VK_EXT_color_write_enable === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setColorWriteEnableEXT( uint32_t attachmentCount, |
| const VULKAN_HPP_NAMESPACE::Bool32 * pColorWriteEnables, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetColorWriteEnableEXT( m_commandBuffer, attachmentCount, reinterpret_cast<const VkBool32 *>( pColorWriteEnables ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setColorWriteEnableEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & colorWriteEnables, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdSetColorWriteEnableEXT && "Function <vkCmdSetColorWriteEnableEXT> requires <VK_EXT_color_write_enable>" ); |
| # endif |
| |
| d.vkCmdSetColorWriteEnableEXT( m_commandBuffer, colorWriteEnables.size(), reinterpret_cast<const VkBool32 *>( colorWriteEnables.data() ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_KHR_ray_tracing_maintenance1 === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::traceRaysIndirect2KHR( VULKAN_HPP_NAMESPACE::DeviceAddress indirectDeviceAddress, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdTraceRaysIndirect2KHR( m_commandBuffer, static_cast<VkDeviceAddress>( indirectDeviceAddress ) ); |
| } |
| |
| //=== VK_EXT_multi_draw === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::drawMultiEXT( uint32_t drawCount, |
| const VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT * pVertexInfo, |
| uint32_t instanceCount, |
| uint32_t firstInstance, |
| uint32_t stride, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdDrawMultiEXT( m_commandBuffer, drawCount, reinterpret_cast<const VkMultiDrawInfoEXT *>( pVertexInfo ), instanceCount, firstInstance, stride ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::drawMultiEXT( VULKAN_HPP_NAMESPACE::StridedArrayProxy<const VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT> const & vertexInfo, |
| uint32_t instanceCount, |
| uint32_t firstInstance, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdDrawMultiEXT && "Function <vkCmdDrawMultiEXT> requires <VK_EXT_multi_draw>" ); |
| # endif |
| |
| d.vkCmdDrawMultiEXT( m_commandBuffer, |
| vertexInfo.size(), |
| reinterpret_cast<const VkMultiDrawInfoEXT *>( vertexInfo.data() ), |
| instanceCount, |
| firstInstance, |
| vertexInfo.stride() ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::drawMultiIndexedEXT( uint32_t drawCount, |
| const VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT * pIndexInfo, |
| uint32_t instanceCount, |
| uint32_t firstInstance, |
| uint32_t stride, |
| const int32_t * pVertexOffset, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdDrawMultiIndexedEXT( |
| m_commandBuffer, drawCount, reinterpret_cast<const VkMultiDrawIndexedInfoEXT *>( pIndexInfo ), instanceCount, firstInstance, stride, pVertexOffset ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void |
| CommandBuffer::drawMultiIndexedEXT( VULKAN_HPP_NAMESPACE::StridedArrayProxy<const VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT> const & indexInfo, |
| uint32_t instanceCount, |
| uint32_t firstInstance, |
| Optional<const int32_t> vertexOffset, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdDrawMultiIndexedEXT && "Function <vkCmdDrawMultiIndexedEXT> requires <VK_EXT_multi_draw>" ); |
| # endif |
| |
| d.vkCmdDrawMultiIndexedEXT( m_commandBuffer, |
| indexInfo.size(), |
| reinterpret_cast<const VkMultiDrawIndexedInfoEXT *>( indexInfo.data() ), |
| instanceCount, |
| firstInstance, |
| indexInfo.stride(), |
| static_cast<const int32_t *>( vertexOffset ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_EXT_opacity_micromap === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createMicromapEXT( const VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::MicromapEXT * pMicromap, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateMicromapEXT( m_device, |
| reinterpret_cast<const VkMicromapCreateInfoEXT *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkMicromapEXT *>( pMicromap ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::MicromapEXT>::type |
| Device::createMicromapEXT( const VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateMicromapEXT && "Function <vkCreateMicromapEXT> requires <VK_EXT_opacity_micromap>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::MicromapEXT micromap; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateMicromapEXT( m_device, |
| reinterpret_cast<const VkMicromapCreateInfoEXT *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkMicromapEXT *>( µmap ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createMicromapEXT" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( micromap ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::MicromapEXT, Dispatch>>::type |
| Device::createMicromapEXTUnique( const VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateMicromapEXT && "Function <vkCreateMicromapEXT> requires <VK_EXT_opacity_micromap>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::MicromapEXT micromap; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateMicromapEXT( m_device, |
| reinterpret_cast<const VkMicromapCreateInfoEXT *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkMicromapEXT *>( µmap ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createMicromapEXTUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::MicromapEXT, Dispatch>( micromap, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyMicromapEXT( VULKAN_HPP_NAMESPACE::MicromapEXT micromap, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyMicromapEXT( m_device, static_cast<VkMicromapEXT>( micromap ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyMicromapEXT( VULKAN_HPP_NAMESPACE::MicromapEXT micromap, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyMicromapEXT && "Function <vkDestroyMicromapEXT> requires <VK_EXT_opacity_micromap>" ); |
| # endif |
| |
| d.vkDestroyMicromapEXT( m_device, |
| static_cast<VkMicromapEXT>( micromap ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::MicromapEXT micromap, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyMicromapEXT( m_device, static_cast<VkMicromapEXT>( micromap ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::MicromapEXT micromap, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyMicromapEXT && "Function <vkDestroyMicromapEXT> requires <VK_EXT_opacity_micromap>" ); |
| # endif |
| |
| d.vkDestroyMicromapEXT( m_device, |
| static_cast<VkMicromapEXT>( micromap ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::buildMicromapsEXT( uint32_t infoCount, |
| const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT * pInfos, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdBuildMicromapsEXT( m_commandBuffer, infoCount, reinterpret_cast<const VkMicromapBuildInfoEXT *>( pInfos ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::buildMicromapsEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT> const & infos, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdBuildMicromapsEXT && "Function <vkCmdBuildMicromapsEXT> requires <VK_EXT_opacity_micromap>" ); |
| # endif |
| |
| d.vkCmdBuildMicromapsEXT( m_commandBuffer, infos.size(), reinterpret_cast<const VkMicromapBuildInfoEXT *>( infos.data() ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::buildMicromapsEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, |
| uint32_t infoCount, |
| const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT * pInfos, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkBuildMicromapsEXT( |
| m_device, static_cast<VkDeferredOperationKHR>( deferredOperation ), infoCount, reinterpret_cast<const VkMicromapBuildInfoEXT *>( pInfos ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result |
| Device::buildMicromapsEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT> const & infos, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkBuildMicromapsEXT && "Function <vkBuildMicromapsEXT> requires <VK_EXT_opacity_micromap>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkBuildMicromapsEXT( |
| m_device, static_cast<VkDeferredOperationKHR>( deferredOperation ), infos.size(), reinterpret_cast<const VkMicromapBuildInfoEXT *>( infos.data() ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( |
| result, |
| VULKAN_HPP_NAMESPACE_STRING "::Device::buildMicromapsEXT", |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR, VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR } ); |
| |
| return static_cast<VULKAN_HPP_NAMESPACE::Result>( result ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyMicromapEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, |
| const VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT * pInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( |
| d.vkCopyMicromapEXT( m_device, static_cast<VkDeferredOperationKHR>( deferredOperation ), reinterpret_cast<const VkCopyMicromapInfoEXT *>( pInfo ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result Device::copyMicromapEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, |
| const VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT & info, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCopyMicromapEXT && "Function <vkCopyMicromapEXT> requires <VK_EXT_opacity_micromap>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCopyMicromapEXT( m_device, static_cast<VkDeferredOperationKHR>( deferredOperation ), reinterpret_cast<const VkCopyMicromapInfoEXT *>( &info ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( |
| result, |
| VULKAN_HPP_NAMESPACE_STRING "::Device::copyMicromapEXT", |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR, VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR } ); |
| |
| return static_cast<VULKAN_HPP_NAMESPACE::Result>( result ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyMicromapToMemoryEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, |
| const VULKAN_HPP_NAMESPACE::CopyMicromapToMemoryInfoEXT * pInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCopyMicromapToMemoryEXT( |
| m_device, static_cast<VkDeferredOperationKHR>( deferredOperation ), reinterpret_cast<const VkCopyMicromapToMemoryInfoEXT *>( pInfo ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result Device::copyMicromapToMemoryEXT( |
| VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, const VULKAN_HPP_NAMESPACE::CopyMicromapToMemoryInfoEXT & info, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCopyMicromapToMemoryEXT && "Function <vkCopyMicromapToMemoryEXT> requires <VK_EXT_opacity_micromap>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCopyMicromapToMemoryEXT( |
| m_device, static_cast<VkDeferredOperationKHR>( deferredOperation ), reinterpret_cast<const VkCopyMicromapToMemoryInfoEXT *>( &info ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( |
| result, |
| VULKAN_HPP_NAMESPACE_STRING "::Device::copyMicromapToMemoryEXT", |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR, VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR } ); |
| |
| return static_cast<VULKAN_HPP_NAMESPACE::Result>( result ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyMemoryToMicromapEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, |
| const VULKAN_HPP_NAMESPACE::CopyMemoryToMicromapInfoEXT * pInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCopyMemoryToMicromapEXT( |
| m_device, static_cast<VkDeferredOperationKHR>( deferredOperation ), reinterpret_cast<const VkCopyMemoryToMicromapInfoEXT *>( pInfo ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result Device::copyMemoryToMicromapEXT( |
| VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, const VULKAN_HPP_NAMESPACE::CopyMemoryToMicromapInfoEXT & info, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCopyMemoryToMicromapEXT && "Function <vkCopyMemoryToMicromapEXT> requires <VK_EXT_opacity_micromap>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCopyMemoryToMicromapEXT( |
| m_device, static_cast<VkDeferredOperationKHR>( deferredOperation ), reinterpret_cast<const VkCopyMemoryToMicromapInfoEXT *>( &info ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( |
| result, |
| VULKAN_HPP_NAMESPACE_STRING "::Device::copyMemoryToMicromapEXT", |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR, VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR } ); |
| |
| return static_cast<VULKAN_HPP_NAMESPACE::Result>( result ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::writeMicromapsPropertiesEXT( uint32_t micromapCount, |
| const VULKAN_HPP_NAMESPACE::MicromapEXT * pMicromaps, |
| VULKAN_HPP_NAMESPACE::QueryType queryType, |
| size_t dataSize, |
| void * pData, |
| size_t stride, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkWriteMicromapsPropertiesEXT( |
| m_device, micromapCount, reinterpret_cast<const VkMicromapEXT *>( pMicromaps ), static_cast<VkQueryType>( queryType ), dataSize, pData, stride ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename DataType, typename DataTypeAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type |
| Device::writeMicromapsPropertiesEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapEXT> const & micromaps, |
| VULKAN_HPP_NAMESPACE::QueryType queryType, |
| size_t dataSize, |
| size_t stride, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkWriteMicromapsPropertiesEXT && "Function <vkWriteMicromapsPropertiesEXT> requires <VK_EXT_opacity_micromap>" ); |
| # endif |
| |
| VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 ); |
| std::vector<DataType, DataTypeAllocator> data( dataSize / sizeof( DataType ) ); |
| VULKAN_HPP_NAMESPACE::Result result = |
| static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkWriteMicromapsPropertiesEXT( m_device, |
| micromaps.size(), |
| reinterpret_cast<const VkMicromapEXT *>( micromaps.data() ), |
| static_cast<VkQueryType>( queryType ), |
| data.size() * sizeof( DataType ), |
| reinterpret_cast<void *>( data.data() ), |
| stride ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::writeMicromapsPropertiesEXT" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); |
| } |
| |
| template <typename DataType, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<DataType>::type |
| Device::writeMicromapsPropertyEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapEXT> const & micromaps, |
| VULKAN_HPP_NAMESPACE::QueryType queryType, |
| size_t stride, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkWriteMicromapsPropertiesEXT && "Function <vkWriteMicromapsPropertiesEXT> requires <VK_EXT_opacity_micromap>" ); |
| # endif |
| |
| DataType data; |
| VULKAN_HPP_NAMESPACE::Result result = |
| static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkWriteMicromapsPropertiesEXT( m_device, |
| micromaps.size(), |
| reinterpret_cast<const VkMicromapEXT *>( micromaps.data() ), |
| static_cast<VkQueryType>( queryType ), |
| sizeof( DataType ), |
| reinterpret_cast<void *>( &data ), |
| stride ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::writeMicromapsPropertyEXT" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::copyMicromapEXT( const VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT * pInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdCopyMicromapEXT( m_commandBuffer, reinterpret_cast<const VkCopyMicromapInfoEXT *>( pInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::copyMicromapEXT( const VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdCopyMicromapEXT && "Function <vkCmdCopyMicromapEXT> requires <VK_EXT_opacity_micromap>" ); |
| # endif |
| |
| d.vkCmdCopyMicromapEXT( m_commandBuffer, reinterpret_cast<const VkCopyMicromapInfoEXT *>( &info ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::copyMicromapToMemoryEXT( const VULKAN_HPP_NAMESPACE::CopyMicromapToMemoryInfoEXT * pInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdCopyMicromapToMemoryEXT( m_commandBuffer, reinterpret_cast<const VkCopyMicromapToMemoryInfoEXT *>( pInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::copyMicromapToMemoryEXT( const VULKAN_HPP_NAMESPACE::CopyMicromapToMemoryInfoEXT & info, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdCopyMicromapToMemoryEXT && "Function <vkCmdCopyMicromapToMemoryEXT> requires <VK_EXT_opacity_micromap>" ); |
| # endif |
| |
| d.vkCmdCopyMicromapToMemoryEXT( m_commandBuffer, reinterpret_cast<const VkCopyMicromapToMemoryInfoEXT *>( &info ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::copyMemoryToMicromapEXT( const VULKAN_HPP_NAMESPACE::CopyMemoryToMicromapInfoEXT * pInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdCopyMemoryToMicromapEXT( m_commandBuffer, reinterpret_cast<const VkCopyMemoryToMicromapInfoEXT *>( pInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::copyMemoryToMicromapEXT( const VULKAN_HPP_NAMESPACE::CopyMemoryToMicromapInfoEXT & info, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdCopyMemoryToMicromapEXT && "Function <vkCmdCopyMemoryToMicromapEXT> requires <VK_EXT_opacity_micromap>" ); |
| # endif |
| |
| d.vkCmdCopyMemoryToMicromapEXT( m_commandBuffer, reinterpret_cast<const VkCopyMemoryToMicromapInfoEXT *>( &info ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::writeMicromapsPropertiesEXT( uint32_t micromapCount, |
| const VULKAN_HPP_NAMESPACE::MicromapEXT * pMicromaps, |
| VULKAN_HPP_NAMESPACE::QueryType queryType, |
| VULKAN_HPP_NAMESPACE::QueryPool queryPool, |
| uint32_t firstQuery, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdWriteMicromapsPropertiesEXT( m_commandBuffer, |
| micromapCount, |
| reinterpret_cast<const VkMicromapEXT *>( pMicromaps ), |
| static_cast<VkQueryType>( queryType ), |
| static_cast<VkQueryPool>( queryPool ), |
| firstQuery ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void |
| CommandBuffer::writeMicromapsPropertiesEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapEXT> const & micromaps, |
| VULKAN_HPP_NAMESPACE::QueryType queryType, |
| VULKAN_HPP_NAMESPACE::QueryPool queryPool, |
| uint32_t firstQuery, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdWriteMicromapsPropertiesEXT && "Function <vkCmdWriteMicromapsPropertiesEXT> requires <VK_EXT_opacity_micromap>" ); |
| # endif |
| |
| d.vkCmdWriteMicromapsPropertiesEXT( m_commandBuffer, |
| micromaps.size(), |
| reinterpret_cast<const VkMicromapEXT *>( micromaps.data() ), |
| static_cast<VkQueryType>( queryType ), |
| static_cast<VkQueryPool>( queryPool ), |
| firstQuery ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::getMicromapCompatibilityEXT( const VULKAN_HPP_NAMESPACE::MicromapVersionInfoEXT * pVersionInfo, |
| VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR * pCompatibility, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetDeviceMicromapCompatibilityEXT( m_device, |
| reinterpret_cast<const VkMicromapVersionInfoEXT *>( pVersionInfo ), |
| reinterpret_cast<VkAccelerationStructureCompatibilityKHR *>( pCompatibility ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR |
| Device::getMicromapCompatibilityEXT( const VULKAN_HPP_NAMESPACE::MicromapVersionInfoEXT & versionInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetDeviceMicromapCompatibilityEXT && "Function <vkGetDeviceMicromapCompatibilityEXT> requires <VK_EXT_opacity_micromap>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR compatibility; |
| d.vkGetDeviceMicromapCompatibilityEXT( m_device, |
| reinterpret_cast<const VkMicromapVersionInfoEXT *>( &versionInfo ), |
| reinterpret_cast<VkAccelerationStructureCompatibilityKHR *>( &compatibility ) ); |
| |
| return compatibility; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::getMicromapBuildSizesEXT( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR buildType, |
| const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT * pBuildInfo, |
| VULKAN_HPP_NAMESPACE::MicromapBuildSizesInfoEXT * pSizeInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetMicromapBuildSizesEXT( m_device, |
| static_cast<VkAccelerationStructureBuildTypeKHR>( buildType ), |
| reinterpret_cast<const VkMicromapBuildInfoEXT *>( pBuildInfo ), |
| reinterpret_cast<VkMicromapBuildSizesInfoEXT *>( pSizeInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MicromapBuildSizesInfoEXT |
| Device::getMicromapBuildSizesEXT( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR buildType, |
| const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT & buildInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetMicromapBuildSizesEXT && "Function <vkGetMicromapBuildSizesEXT> requires <VK_EXT_opacity_micromap>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::MicromapBuildSizesInfoEXT sizeInfo; |
| d.vkGetMicromapBuildSizesEXT( m_device, |
| static_cast<VkAccelerationStructureBuildTypeKHR>( buildType ), |
| reinterpret_cast<const VkMicromapBuildInfoEXT *>( &buildInfo ), |
| reinterpret_cast<VkMicromapBuildSizesInfoEXT *>( &sizeInfo ) ); |
| |
| return sizeInfo; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_HUAWEI_cluster_culling_shader === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void |
| CommandBuffer::drawClusterHUAWEI( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdDrawClusterHUAWEI( m_commandBuffer, groupCountX, groupCountY, groupCountZ ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::drawClusterIndirectHUAWEI( VULKAN_HPP_NAMESPACE::Buffer buffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize offset, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdDrawClusterIndirectHUAWEI( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ) ); |
| } |
| |
| //=== VK_EXT_pageable_device_local_memory === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::setMemoryPriorityEXT( VULKAN_HPP_NAMESPACE::DeviceMemory memory, float priority, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkSetDeviceMemoryPriorityEXT( m_device, static_cast<VkDeviceMemory>( memory ), priority ); |
| } |
| |
| //=== VK_KHR_maintenance4 === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::getBufferMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements * pInfo, |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetDeviceBufferMemoryRequirementsKHR( |
| m_device, reinterpret_cast<const VkDeviceBufferMemoryRequirements *>( pInfo ), reinterpret_cast<VkMemoryRequirements2 *>( pMemoryRequirements ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2 |
| Device::getBufferMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetDeviceBufferMemoryRequirementsKHR && |
| "Function <vkGetDeviceBufferMemoryRequirementsKHR> requires <VK_KHR_maintenance4> or <VK_VERSION_1_3>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements; |
| d.vkGetDeviceBufferMemoryRequirementsKHR( |
| m_device, reinterpret_cast<const VkDeviceBufferMemoryRequirements *>( &info ), reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) ); |
| |
| return memoryRequirements; |
| } |
| |
| template <typename X, typename Y, typename... Z, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> |
| Device::getBufferMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetDeviceBufferMemoryRequirementsKHR && |
| "Function <vkGetDeviceBufferMemoryRequirementsKHR> requires <VK_KHR_maintenance4> or <VK_VERSION_1_3>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain; |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>(); |
| d.vkGetDeviceBufferMemoryRequirementsKHR( |
| m_device, reinterpret_cast<const VkDeviceBufferMemoryRequirements *>( &info ), reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) ); |
| |
| return structureChain; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::getImageMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements * pInfo, |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetDeviceImageMemoryRequirementsKHR( |
| m_device, reinterpret_cast<const VkDeviceImageMemoryRequirements *>( pInfo ), reinterpret_cast<VkMemoryRequirements2 *>( pMemoryRequirements ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2 |
| Device::getImageMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetDeviceImageMemoryRequirementsKHR && |
| "Function <vkGetDeviceImageMemoryRequirementsKHR> requires <VK_KHR_maintenance4> or <VK_VERSION_1_3>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements; |
| d.vkGetDeviceImageMemoryRequirementsKHR( |
| m_device, reinterpret_cast<const VkDeviceImageMemoryRequirements *>( &info ), reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) ); |
| |
| return memoryRequirements; |
| } |
| |
| template <typename X, typename Y, typename... Z, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> |
| Device::getImageMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetDeviceImageMemoryRequirementsKHR && |
| "Function <vkGetDeviceImageMemoryRequirementsKHR> requires <VK_KHR_maintenance4> or <VK_VERSION_1_3>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain; |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>(); |
| d.vkGetDeviceImageMemoryRequirementsKHR( |
| m_device, reinterpret_cast<const VkDeviceImageMemoryRequirements *>( &info ), reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) ); |
| |
| return structureChain; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements * pInfo, |
| uint32_t * pSparseMemoryRequirementCount, |
| VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 * pSparseMemoryRequirements, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetDeviceImageSparseMemoryRequirementsKHR( m_device, |
| reinterpret_cast<const VkDeviceImageMemoryRequirements *>( pInfo ), |
| pSparseMemoryRequirementCount, |
| reinterpret_cast<VkSparseImageMemoryRequirements2 *>( pSparseMemoryRequirements ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename SparseImageMemoryRequirements2Allocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> |
| Device::getImageSparseMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetDeviceImageSparseMemoryRequirementsKHR && |
| "Function <vkGetDeviceImageSparseMemoryRequirementsKHR> requires <VK_KHR_maintenance4> or <VK_VERSION_1_3>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> sparseMemoryRequirements; |
| uint32_t sparseMemoryRequirementCount; |
| d.vkGetDeviceImageSparseMemoryRequirementsKHR( |
| m_device, reinterpret_cast<const VkDeviceImageMemoryRequirements *>( &info ), &sparseMemoryRequirementCount, nullptr ); |
| sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); |
| d.vkGetDeviceImageSparseMemoryRequirementsKHR( m_device, |
| reinterpret_cast<const VkDeviceImageMemoryRequirements *>( &info ), |
| &sparseMemoryRequirementCount, |
| reinterpret_cast<VkSparseImageMemoryRequirements2 *>( sparseMemoryRequirements.data() ) ); |
| |
| VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() ); |
| if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() ) |
| { |
| sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); |
| } |
| return sparseMemoryRequirements; |
| } |
| |
| template <typename SparseImageMemoryRequirements2Allocator, |
| typename Dispatch, |
| typename std::enable_if< |
| std::is_same<typename SparseImageMemoryRequirements2Allocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>::value, |
| int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> |
| Device::getImageSparseMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info, |
| SparseImageMemoryRequirements2Allocator & sparseImageMemoryRequirements2Allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetDeviceImageSparseMemoryRequirementsKHR && |
| "Function <vkGetDeviceImageSparseMemoryRequirementsKHR> requires <VK_KHR_maintenance4> or <VK_VERSION_1_3>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> sparseMemoryRequirements( |
| sparseImageMemoryRequirements2Allocator ); |
| uint32_t sparseMemoryRequirementCount; |
| d.vkGetDeviceImageSparseMemoryRequirementsKHR( |
| m_device, reinterpret_cast<const VkDeviceImageMemoryRequirements *>( &info ), &sparseMemoryRequirementCount, nullptr ); |
| sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); |
| d.vkGetDeviceImageSparseMemoryRequirementsKHR( m_device, |
| reinterpret_cast<const VkDeviceImageMemoryRequirements *>( &info ), |
| &sparseMemoryRequirementCount, |
| reinterpret_cast<VkSparseImageMemoryRequirements2 *>( sparseMemoryRequirements.data() ) ); |
| |
| VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() ); |
| if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() ) |
| { |
| sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); |
| } |
| return sparseMemoryRequirements; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_VALVE_descriptor_set_host_mapping === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::getDescriptorSetLayoutHostMappingInfoVALVE( const VULKAN_HPP_NAMESPACE::DescriptorSetBindingReferenceVALVE * pBindingReference, |
| VULKAN_HPP_NAMESPACE::DescriptorSetLayoutHostMappingInfoVALVE * pHostMapping, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetDescriptorSetLayoutHostMappingInfoVALVE( m_device, |
| reinterpret_cast<const VkDescriptorSetBindingReferenceVALVE *>( pBindingReference ), |
| reinterpret_cast<VkDescriptorSetLayoutHostMappingInfoVALVE *>( pHostMapping ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DescriptorSetLayoutHostMappingInfoVALVE |
| Device::getDescriptorSetLayoutHostMappingInfoVALVE( const VULKAN_HPP_NAMESPACE::DescriptorSetBindingReferenceVALVE & bindingReference, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetDescriptorSetLayoutHostMappingInfoVALVE && |
| "Function <vkGetDescriptorSetLayoutHostMappingInfoVALVE> requires <VK_VALVE_descriptor_set_host_mapping>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::DescriptorSetLayoutHostMappingInfoVALVE hostMapping; |
| d.vkGetDescriptorSetLayoutHostMappingInfoVALVE( m_device, |
| reinterpret_cast<const VkDescriptorSetBindingReferenceVALVE *>( &bindingReference ), |
| reinterpret_cast<VkDescriptorSetLayoutHostMappingInfoVALVE *>( &hostMapping ) ); |
| |
| return hostMapping; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void |
| Device::getDescriptorSetHostMappingVALVE( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet, void ** ppData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetDescriptorSetHostMappingVALVE( m_device, static_cast<VkDescriptorSet>( descriptorSet ), ppData ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE void * Device::getDescriptorSetHostMappingVALVE( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetDescriptorSetHostMappingVALVE && |
| "Function <vkGetDescriptorSetHostMappingVALVE> requires <VK_VALVE_descriptor_set_host_mapping>" ); |
| # endif |
| |
| void * pData; |
| d.vkGetDescriptorSetHostMappingVALVE( m_device, static_cast<VkDescriptorSet>( descriptorSet ), &pData ); |
| |
| return pData; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_NV_copy_memory_indirect === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::copyMemoryIndirectNV( VULKAN_HPP_NAMESPACE::DeviceAddress copyBufferAddress, |
| uint32_t copyCount, |
| uint32_t stride, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdCopyMemoryIndirectNV( m_commandBuffer, static_cast<VkDeviceAddress>( copyBufferAddress ), copyCount, stride ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::copyMemoryToImageIndirectNV( VULKAN_HPP_NAMESPACE::DeviceAddress copyBufferAddress, |
| uint32_t copyCount, |
| uint32_t stride, |
| VULKAN_HPP_NAMESPACE::Image dstImage, |
| VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, |
| const VULKAN_HPP_NAMESPACE::ImageSubresourceLayers * pImageSubresources, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdCopyMemoryToImageIndirectNV( m_commandBuffer, |
| static_cast<VkDeviceAddress>( copyBufferAddress ), |
| copyCount, |
| stride, |
| static_cast<VkImage>( dstImage ), |
| static_cast<VkImageLayout>( dstImageLayout ), |
| reinterpret_cast<const VkImageSubresourceLayers *>( pImageSubresources ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void |
| CommandBuffer::copyMemoryToImageIndirectNV( VULKAN_HPP_NAMESPACE::DeviceAddress copyBufferAddress, |
| uint32_t stride, |
| VULKAN_HPP_NAMESPACE::Image dstImage, |
| VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceLayers> const & imageSubresources, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdCopyMemoryToImageIndirectNV && "Function <vkCmdCopyMemoryToImageIndirectNV> requires <VK_NV_copy_memory_indirect>" ); |
| # endif |
| |
| d.vkCmdCopyMemoryToImageIndirectNV( m_commandBuffer, |
| static_cast<VkDeviceAddress>( copyBufferAddress ), |
| imageSubresources.size(), |
| stride, |
| static_cast<VkImage>( dstImage ), |
| static_cast<VkImageLayout>( dstImageLayout ), |
| reinterpret_cast<const VkImageSubresourceLayers *>( imageSubresources.data() ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_NV_memory_decompression === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::decompressMemoryNV( uint32_t decompressRegionCount, |
| const VULKAN_HPP_NAMESPACE::DecompressMemoryRegionNV * pDecompressMemoryRegions, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdDecompressMemoryNV( m_commandBuffer, decompressRegionCount, reinterpret_cast<const VkDecompressMemoryRegionNV *>( pDecompressMemoryRegions ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void |
| CommandBuffer::decompressMemoryNV( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DecompressMemoryRegionNV> const & decompressMemoryRegions, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdDecompressMemoryNV && "Function <vkCmdDecompressMemoryNV> requires <VK_NV_memory_decompression>" ); |
| # endif |
| |
| d.vkCmdDecompressMemoryNV( |
| m_commandBuffer, decompressMemoryRegions.size(), reinterpret_cast<const VkDecompressMemoryRegionNV *>( decompressMemoryRegions.data() ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::decompressMemoryIndirectCountNV( VULKAN_HPP_NAMESPACE::DeviceAddress indirectCommandsAddress, |
| VULKAN_HPP_NAMESPACE::DeviceAddress indirectCommandsCountAddress, |
| uint32_t stride, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdDecompressMemoryIndirectCountNV( |
| m_commandBuffer, static_cast<VkDeviceAddress>( indirectCommandsAddress ), static_cast<VkDeviceAddress>( indirectCommandsCountAddress ), stride ); |
| } |
| |
| //=== VK_NV_device_generated_commands_compute === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::getPipelineIndirectMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo * pCreateInfo, |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetPipelineIndirectMemoryRequirementsNV( |
| m_device, reinterpret_cast<const VkComputePipelineCreateInfo *>( pCreateInfo ), reinterpret_cast<VkMemoryRequirements2 *>( pMemoryRequirements ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2 |
| Device::getPipelineIndirectMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo & createInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPipelineIndirectMemoryRequirementsNV && |
| "Function <vkGetPipelineIndirectMemoryRequirementsNV> requires <VK_NV_device_generated_commands_compute>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements; |
| d.vkGetPipelineIndirectMemoryRequirementsNV( |
| m_device, reinterpret_cast<const VkComputePipelineCreateInfo *>( &createInfo ), reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) ); |
| |
| return memoryRequirements; |
| } |
| |
| template <typename X, typename Y, typename... Z, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> |
| Device::getPipelineIndirectMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo & createInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPipelineIndirectMemoryRequirementsNV && |
| "Function <vkGetPipelineIndirectMemoryRequirementsNV> requires <VK_NV_device_generated_commands_compute>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain; |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>(); |
| d.vkGetPipelineIndirectMemoryRequirementsNV( |
| m_device, reinterpret_cast<const VkComputePipelineCreateInfo *>( &createInfo ), reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) ); |
| |
| return structureChain; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::updatePipelineIndirectBufferNV( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, |
| VULKAN_HPP_NAMESPACE::Pipeline pipeline, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdUpdatePipelineIndirectBufferNV( m_commandBuffer, static_cast<VkPipelineBindPoint>( pipelineBindPoint ), static_cast<VkPipeline>( pipeline ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE DeviceAddress Device::getPipelineIndirectAddressNV( const VULKAN_HPP_NAMESPACE::PipelineIndirectDeviceAddressInfoNV * pInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<DeviceAddress>( |
| d.vkGetPipelineIndirectDeviceAddressNV( m_device, reinterpret_cast<const VkPipelineIndirectDeviceAddressInfoNV *>( pInfo ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceAddress |
| Device::getPipelineIndirectAddressNV( const VULKAN_HPP_NAMESPACE::PipelineIndirectDeviceAddressInfoNV & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPipelineIndirectDeviceAddressNV && |
| "Function <vkGetPipelineIndirectDeviceAddressNV> requires <VK_NV_device_generated_commands_compute>" ); |
| # endif |
| |
| VkDeviceAddress result = d.vkGetPipelineIndirectDeviceAddressNV( m_device, reinterpret_cast<const VkPipelineIndirectDeviceAddressInfoNV *>( &info ) ); |
| |
| return static_cast<VULKAN_HPP_NAMESPACE::DeviceAddress>( result ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_EXT_extended_dynamic_state3 === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setDepthClampEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthClampEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetDepthClampEnableEXT( m_commandBuffer, static_cast<VkBool32>( depthClampEnable ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setPolygonModeEXT( VULKAN_HPP_NAMESPACE::PolygonMode polygonMode, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetPolygonModeEXT( m_commandBuffer, static_cast<VkPolygonMode>( polygonMode ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setRasterizationSamplesEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits rasterizationSamples, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetRasterizationSamplesEXT( m_commandBuffer, static_cast<VkSampleCountFlagBits>( rasterizationSamples ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setSampleMaskEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples, |
| const VULKAN_HPP_NAMESPACE::SampleMask * pSampleMask, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetSampleMaskEXT( m_commandBuffer, static_cast<VkSampleCountFlagBits>( samples ), reinterpret_cast<const VkSampleMask *>( pSampleMask ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setSampleMaskEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SampleMask> const & sampleMask, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdSetSampleMaskEXT && "Function <vkCmdSetSampleMaskEXT> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" ); |
| # endif |
| # ifdef VULKAN_HPP_NO_EXCEPTIONS |
| VULKAN_HPP_ASSERT( sampleMask.size() == ( static_cast<uint32_t>( samples ) + 31 ) / 32 ); |
| # else |
| if ( sampleMask.size() != ( static_cast<uint32_t>( samples ) + 31 ) / 32 ) |
| { |
| throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::setSampleMaskEXT: sampleMask.size() != ( static_cast<uint32_t>( samples ) + 31 ) / 32" ); |
| } |
| # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ |
| |
| d.vkCmdSetSampleMaskEXT( m_commandBuffer, static_cast<VkSampleCountFlagBits>( samples ), reinterpret_cast<const VkSampleMask *>( sampleMask.data() ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setAlphaToCoverageEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 alphaToCoverageEnable, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetAlphaToCoverageEnableEXT( m_commandBuffer, static_cast<VkBool32>( alphaToCoverageEnable ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setAlphaToOneEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 alphaToOneEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetAlphaToOneEnableEXT( m_commandBuffer, static_cast<VkBool32>( alphaToOneEnable ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setLogicOpEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 logicOpEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetLogicOpEnableEXT( m_commandBuffer, static_cast<VkBool32>( logicOpEnable ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setColorBlendEnableEXT( uint32_t firstAttachment, |
| uint32_t attachmentCount, |
| const VULKAN_HPP_NAMESPACE::Bool32 * pColorBlendEnables, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetColorBlendEnableEXT( m_commandBuffer, firstAttachment, attachmentCount, reinterpret_cast<const VkBool32 *>( pColorBlendEnables ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setColorBlendEnableEXT( uint32_t firstAttachment, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & colorBlendEnables, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdSetColorBlendEnableEXT && |
| "Function <vkCmdSetColorBlendEnableEXT> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" ); |
| # endif |
| |
| d.vkCmdSetColorBlendEnableEXT( m_commandBuffer, firstAttachment, colorBlendEnables.size(), reinterpret_cast<const VkBool32 *>( colorBlendEnables.data() ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setColorBlendEquationEXT( uint32_t firstAttachment, |
| uint32_t attachmentCount, |
| const VULKAN_HPP_NAMESPACE::ColorBlendEquationEXT * pColorBlendEquations, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetColorBlendEquationEXT( |
| m_commandBuffer, firstAttachment, attachmentCount, reinterpret_cast<const VkColorBlendEquationEXT *>( pColorBlendEquations ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void |
| CommandBuffer::setColorBlendEquationEXT( uint32_t firstAttachment, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ColorBlendEquationEXT> const & colorBlendEquations, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdSetColorBlendEquationEXT && |
| "Function <vkCmdSetColorBlendEquationEXT> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" ); |
| # endif |
| |
| d.vkCmdSetColorBlendEquationEXT( |
| m_commandBuffer, firstAttachment, colorBlendEquations.size(), reinterpret_cast<const VkColorBlendEquationEXT *>( colorBlendEquations.data() ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setColorWriteMaskEXT( uint32_t firstAttachment, |
| uint32_t attachmentCount, |
| const VULKAN_HPP_NAMESPACE::ColorComponentFlags * pColorWriteMasks, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetColorWriteMaskEXT( m_commandBuffer, firstAttachment, attachmentCount, reinterpret_cast<const VkColorComponentFlags *>( pColorWriteMasks ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void |
| CommandBuffer::setColorWriteMaskEXT( uint32_t firstAttachment, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ColorComponentFlags> const & colorWriteMasks, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdSetColorWriteMaskEXT && |
| "Function <vkCmdSetColorWriteMaskEXT> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" ); |
| # endif |
| |
| d.vkCmdSetColorWriteMaskEXT( |
| m_commandBuffer, firstAttachment, colorWriteMasks.size(), reinterpret_cast<const VkColorComponentFlags *>( colorWriteMasks.data() ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setTessellationDomainOriginEXT( VULKAN_HPP_NAMESPACE::TessellationDomainOrigin domainOrigin, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetTessellationDomainOriginEXT( m_commandBuffer, static_cast<VkTessellationDomainOrigin>( domainOrigin ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setRasterizationStreamEXT( uint32_t rasterizationStream, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetRasterizationStreamEXT( m_commandBuffer, rasterizationStream ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void |
| CommandBuffer::setConservativeRasterizationModeEXT( VULKAN_HPP_NAMESPACE::ConservativeRasterizationModeEXT conservativeRasterizationMode, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetConservativeRasterizationModeEXT( m_commandBuffer, static_cast<VkConservativeRasterizationModeEXT>( conservativeRasterizationMode ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setExtraPrimitiveOverestimationSizeEXT( float extraPrimitiveOverestimationSize, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetExtraPrimitiveOverestimationSizeEXT( m_commandBuffer, extraPrimitiveOverestimationSize ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setDepthClipEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthClipEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetDepthClipEnableEXT( m_commandBuffer, static_cast<VkBool32>( depthClipEnable ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setSampleLocationsEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 sampleLocationsEnable, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetSampleLocationsEnableEXT( m_commandBuffer, static_cast<VkBool32>( sampleLocationsEnable ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setColorBlendAdvancedEXT( uint32_t firstAttachment, |
| uint32_t attachmentCount, |
| const VULKAN_HPP_NAMESPACE::ColorBlendAdvancedEXT * pColorBlendAdvanced, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetColorBlendAdvancedEXT( |
| m_commandBuffer, firstAttachment, attachmentCount, reinterpret_cast<const VkColorBlendAdvancedEXT *>( pColorBlendAdvanced ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void |
| CommandBuffer::setColorBlendAdvancedEXT( uint32_t firstAttachment, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ColorBlendAdvancedEXT> const & colorBlendAdvanced, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdSetColorBlendAdvancedEXT && |
| "Function <vkCmdSetColorBlendAdvancedEXT> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" ); |
| # endif |
| |
| d.vkCmdSetColorBlendAdvancedEXT( |
| m_commandBuffer, firstAttachment, colorBlendAdvanced.size(), reinterpret_cast<const VkColorBlendAdvancedEXT *>( colorBlendAdvanced.data() ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setProvokingVertexModeEXT( VULKAN_HPP_NAMESPACE::ProvokingVertexModeEXT provokingVertexMode, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetProvokingVertexModeEXT( m_commandBuffer, static_cast<VkProvokingVertexModeEXT>( provokingVertexMode ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setLineRasterizationModeEXT( VULKAN_HPP_NAMESPACE::LineRasterizationModeEXT lineRasterizationMode, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetLineRasterizationModeEXT( m_commandBuffer, static_cast<VkLineRasterizationModeEXT>( lineRasterizationMode ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setLineStippleEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 stippledLineEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetLineStippleEnableEXT( m_commandBuffer, static_cast<VkBool32>( stippledLineEnable ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setDepthClipNegativeOneToOneEXT( VULKAN_HPP_NAMESPACE::Bool32 negativeOneToOne, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetDepthClipNegativeOneToOneEXT( m_commandBuffer, static_cast<VkBool32>( negativeOneToOne ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setViewportWScalingEnableNV( VULKAN_HPP_NAMESPACE::Bool32 viewportWScalingEnable, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetViewportWScalingEnableNV( m_commandBuffer, static_cast<VkBool32>( viewportWScalingEnable ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setViewportSwizzleNV( uint32_t firstViewport, |
| uint32_t viewportCount, |
| const VULKAN_HPP_NAMESPACE::ViewportSwizzleNV * pViewportSwizzles, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetViewportSwizzleNV( m_commandBuffer, firstViewport, viewportCount, reinterpret_cast<const VkViewportSwizzleNV *>( pViewportSwizzles ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void |
| CommandBuffer::setViewportSwizzleNV( uint32_t firstViewport, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ViewportSwizzleNV> const & viewportSwizzles, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdSetViewportSwizzleNV && |
| "Function <vkCmdSetViewportSwizzleNV> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" ); |
| # endif |
| |
| d.vkCmdSetViewportSwizzleNV( |
| m_commandBuffer, firstViewport, viewportSwizzles.size(), reinterpret_cast<const VkViewportSwizzleNV *>( viewportSwizzles.data() ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setCoverageToColorEnableNV( VULKAN_HPP_NAMESPACE::Bool32 coverageToColorEnable, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetCoverageToColorEnableNV( m_commandBuffer, static_cast<VkBool32>( coverageToColorEnable ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setCoverageToColorLocationNV( uint32_t coverageToColorLocation, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetCoverageToColorLocationNV( m_commandBuffer, coverageToColorLocation ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setCoverageModulationModeNV( VULKAN_HPP_NAMESPACE::CoverageModulationModeNV coverageModulationMode, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetCoverageModulationModeNV( m_commandBuffer, static_cast<VkCoverageModulationModeNV>( coverageModulationMode ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setCoverageModulationTableEnableNV( VULKAN_HPP_NAMESPACE::Bool32 coverageModulationTableEnable, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetCoverageModulationTableEnableNV( m_commandBuffer, static_cast<VkBool32>( coverageModulationTableEnable ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setCoverageModulationTableNV( uint32_t coverageModulationTableCount, |
| const float * pCoverageModulationTable, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetCoverageModulationTableNV( m_commandBuffer, coverageModulationTableCount, pCoverageModulationTable ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setCoverageModulationTableNV( VULKAN_HPP_NAMESPACE::ArrayProxy<const float> const & coverageModulationTable, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdSetCoverageModulationTableNV && |
| "Function <vkCmdSetCoverageModulationTableNV> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" ); |
| # endif |
| |
| d.vkCmdSetCoverageModulationTableNV( m_commandBuffer, coverageModulationTable.size(), coverageModulationTable.data() ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setShadingRateImageEnableNV( VULKAN_HPP_NAMESPACE::Bool32 shadingRateImageEnable, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetShadingRateImageEnableNV( m_commandBuffer, static_cast<VkBool32>( shadingRateImageEnable ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setRepresentativeFragmentTestEnableNV( VULKAN_HPP_NAMESPACE::Bool32 representativeFragmentTestEnable, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetRepresentativeFragmentTestEnableNV( m_commandBuffer, static_cast<VkBool32>( representativeFragmentTestEnable ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setCoverageReductionModeNV( VULKAN_HPP_NAMESPACE::CoverageReductionModeNV coverageReductionMode, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetCoverageReductionModeNV( m_commandBuffer, static_cast<VkCoverageReductionModeNV>( coverageReductionMode ) ); |
| } |
| |
| //=== VK_EXT_shader_module_identifier === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::getShaderModuleIdentifierEXT( VULKAN_HPP_NAMESPACE::ShaderModule shaderModule, |
| VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT * pIdentifier, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetShaderModuleIdentifierEXT( m_device, static_cast<VkShaderModule>( shaderModule ), reinterpret_cast<VkShaderModuleIdentifierEXT *>( pIdentifier ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT |
| Device::getShaderModuleIdentifierEXT( VULKAN_HPP_NAMESPACE::ShaderModule shaderModule, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetShaderModuleIdentifierEXT && "Function <vkGetShaderModuleIdentifierEXT> requires <VK_EXT_shader_module_identifier>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT identifier; |
| d.vkGetShaderModuleIdentifierEXT( m_device, static_cast<VkShaderModule>( shaderModule ), reinterpret_cast<VkShaderModuleIdentifierEXT *>( &identifier ) ); |
| |
| return identifier; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::getShaderModuleCreateInfoIdentifierEXT( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo * pCreateInfo, |
| VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT * pIdentifier, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetShaderModuleCreateInfoIdentifierEXT( |
| m_device, reinterpret_cast<const VkShaderModuleCreateInfo *>( pCreateInfo ), reinterpret_cast<VkShaderModuleIdentifierEXT *>( pIdentifier ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT |
| Device::getShaderModuleCreateInfoIdentifierEXT( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo & createInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetShaderModuleCreateInfoIdentifierEXT && |
| "Function <vkGetShaderModuleCreateInfoIdentifierEXT> requires <VK_EXT_shader_module_identifier>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT identifier; |
| d.vkGetShaderModuleCreateInfoIdentifierEXT( |
| m_device, reinterpret_cast<const VkShaderModuleCreateInfo *>( &createInfo ), reinterpret_cast<VkShaderModuleIdentifierEXT *>( &identifier ) ); |
| |
| return identifier; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_NV_optical_flow === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| PhysicalDevice::getOpticalFlowImageFormatsNV( const VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatInfoNV * pOpticalFlowImageFormatInfo, |
| uint32_t * pFormatCount, |
| VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV * pImageFormatProperties, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( |
| d.vkGetPhysicalDeviceOpticalFlowImageFormatsNV( m_physicalDevice, |
| reinterpret_cast<const VkOpticalFlowImageFormatInfoNV *>( pOpticalFlowImageFormatInfo ), |
| pFormatCount, |
| reinterpret_cast<VkOpticalFlowImageFormatPropertiesNV *>( pImageFormatProperties ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename OpticalFlowImageFormatPropertiesNVAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE |
| typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV, OpticalFlowImageFormatPropertiesNVAllocator>>::type |
| PhysicalDevice::getOpticalFlowImageFormatsNV( const VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatInfoNV & opticalFlowImageFormatInfo, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceOpticalFlowImageFormatsNV && |
| "Function <vkGetPhysicalDeviceOpticalFlowImageFormatsNV> requires <VK_NV_optical_flow>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV, OpticalFlowImageFormatPropertiesNVAllocator> imageFormatProperties; |
| uint32_t formatCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPhysicalDeviceOpticalFlowImageFormatsNV( |
| m_physicalDevice, reinterpret_cast<const VkOpticalFlowImageFormatInfoNV *>( &opticalFlowImageFormatInfo ), &formatCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && formatCount ) |
| { |
| imageFormatProperties.resize( formatCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetPhysicalDeviceOpticalFlowImageFormatsNV( m_physicalDevice, |
| reinterpret_cast<const VkOpticalFlowImageFormatInfoNV *>( &opticalFlowImageFormatInfo ), |
| &formatCount, |
| reinterpret_cast<VkOpticalFlowImageFormatPropertiesNV *>( imageFormatProperties.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getOpticalFlowImageFormatsNV" ); |
| VULKAN_HPP_ASSERT( formatCount <= imageFormatProperties.size() ); |
| if ( formatCount < imageFormatProperties.size() ) |
| { |
| imageFormatProperties.resize( formatCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( imageFormatProperties ) ); |
| } |
| |
| template <typename OpticalFlowImageFormatPropertiesNVAllocator, |
| typename Dispatch, |
| typename std::enable_if< |
| std::is_same<typename OpticalFlowImageFormatPropertiesNVAllocator::value_type, VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV>::value, |
| int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE |
| typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV, OpticalFlowImageFormatPropertiesNVAllocator>>::type |
| PhysicalDevice::getOpticalFlowImageFormatsNV( const VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatInfoNV & opticalFlowImageFormatInfo, |
| OpticalFlowImageFormatPropertiesNVAllocator & opticalFlowImageFormatPropertiesNVAllocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceOpticalFlowImageFormatsNV && |
| "Function <vkGetPhysicalDeviceOpticalFlowImageFormatsNV> requires <VK_NV_optical_flow>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV, OpticalFlowImageFormatPropertiesNVAllocator> imageFormatProperties( |
| opticalFlowImageFormatPropertiesNVAllocator ); |
| uint32_t formatCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPhysicalDeviceOpticalFlowImageFormatsNV( |
| m_physicalDevice, reinterpret_cast<const VkOpticalFlowImageFormatInfoNV *>( &opticalFlowImageFormatInfo ), &formatCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && formatCount ) |
| { |
| imageFormatProperties.resize( formatCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetPhysicalDeviceOpticalFlowImageFormatsNV( m_physicalDevice, |
| reinterpret_cast<const VkOpticalFlowImageFormatInfoNV *>( &opticalFlowImageFormatInfo ), |
| &formatCount, |
| reinterpret_cast<VkOpticalFlowImageFormatPropertiesNV *>( imageFormatProperties.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getOpticalFlowImageFormatsNV" ); |
| VULKAN_HPP_ASSERT( formatCount <= imageFormatProperties.size() ); |
| if ( formatCount < imageFormatProperties.size() ) |
| { |
| imageFormatProperties.resize( formatCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( imageFormatProperties ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createOpticalFlowSessionNV( const VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV * pSession, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateOpticalFlowSessionNV( m_device, |
| reinterpret_cast<const VkOpticalFlowSessionCreateInfoNV *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkOpticalFlowSessionNV *>( pSession ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV>::type |
| Device::createOpticalFlowSessionNV( const VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateOpticalFlowSessionNV && "Function <vkCreateOpticalFlowSessionNV> requires <VK_NV_optical_flow>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateOpticalFlowSessionNV( |
| m_device, |
| reinterpret_cast<const VkOpticalFlowSessionCreateInfoNV *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkOpticalFlowSessionNV *>( &session ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createOpticalFlowSessionNV" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( session ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV, Dispatch>>::type |
| Device::createOpticalFlowSessionNVUnique( const VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateOpticalFlowSessionNV && "Function <vkCreateOpticalFlowSessionNV> requires <VK_NV_optical_flow>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateOpticalFlowSessionNV( |
| m_device, |
| reinterpret_cast<const VkOpticalFlowSessionCreateInfoNV *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkOpticalFlowSessionNV *>( &session ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createOpticalFlowSessionNVUnique" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV, Dispatch>( session, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyOpticalFlowSessionNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyOpticalFlowSessionNV( m_device, static_cast<VkOpticalFlowSessionNV>( session ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyOpticalFlowSessionNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyOpticalFlowSessionNV && "Function <vkDestroyOpticalFlowSessionNV> requires <VK_NV_optical_flow>" ); |
| # endif |
| |
| d.vkDestroyOpticalFlowSessionNV( |
| m_device, |
| static_cast<VkOpticalFlowSessionNV>( session ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyOpticalFlowSessionNV( m_device, static_cast<VkOpticalFlowSessionNV>( session ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyOpticalFlowSessionNV && "Function <vkDestroyOpticalFlowSessionNV> requires <VK_NV_optical_flow>" ); |
| # endif |
| |
| d.vkDestroyOpticalFlowSessionNV( |
| m_device, |
| static_cast<VkOpticalFlowSessionNV>( session ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::bindOpticalFlowSessionImageNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session, |
| VULKAN_HPP_NAMESPACE::OpticalFlowSessionBindingPointNV bindingPoint, |
| VULKAN_HPP_NAMESPACE::ImageView view, |
| VULKAN_HPP_NAMESPACE::ImageLayout layout, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkBindOpticalFlowSessionImageNV( m_device, |
| static_cast<VkOpticalFlowSessionNV>( session ), |
| static_cast<VkOpticalFlowSessionBindingPointNV>( bindingPoint ), |
| static_cast<VkImageView>( view ), |
| static_cast<VkImageLayout>( layout ) ) ); |
| } |
| #else |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type |
| Device::bindOpticalFlowSessionImageNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session, |
| VULKAN_HPP_NAMESPACE::OpticalFlowSessionBindingPointNV bindingPoint, |
| VULKAN_HPP_NAMESPACE::ImageView view, |
| VULKAN_HPP_NAMESPACE::ImageLayout layout, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkBindOpticalFlowSessionImageNV && "Function <vkBindOpticalFlowSessionImageNV> requires <VK_NV_optical_flow>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = |
| static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkBindOpticalFlowSessionImageNV( m_device, |
| static_cast<VkOpticalFlowSessionNV>( session ), |
| static_cast<VkOpticalFlowSessionBindingPointNV>( bindingPoint ), |
| static_cast<VkImageView>( view ), |
| static_cast<VkImageLayout>( layout ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindOpticalFlowSessionImageNV" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::opticalFlowExecuteNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session, |
| const VULKAN_HPP_NAMESPACE::OpticalFlowExecuteInfoNV * pExecuteInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdOpticalFlowExecuteNV( |
| m_commandBuffer, static_cast<VkOpticalFlowSessionNV>( session ), reinterpret_cast<const VkOpticalFlowExecuteInfoNV *>( pExecuteInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::opticalFlowExecuteNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session, |
| const VULKAN_HPP_NAMESPACE::OpticalFlowExecuteInfoNV & executeInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdOpticalFlowExecuteNV && "Function <vkCmdOpticalFlowExecuteNV> requires <VK_NV_optical_flow>" ); |
| # endif |
| |
| d.vkCmdOpticalFlowExecuteNV( |
| m_commandBuffer, static_cast<VkOpticalFlowSessionNV>( session ), reinterpret_cast<const VkOpticalFlowExecuteInfoNV *>( &executeInfo ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_KHR_maintenance5 === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::bindIndexBuffer2KHR( VULKAN_HPP_NAMESPACE::Buffer buffer, |
| VULKAN_HPP_NAMESPACE::DeviceSize offset, |
| VULKAN_HPP_NAMESPACE::DeviceSize size, |
| VULKAN_HPP_NAMESPACE::IndexType indexType, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdBindIndexBuffer2KHR( m_commandBuffer, |
| static_cast<VkBuffer>( buffer ), |
| static_cast<VkDeviceSize>( offset ), |
| static_cast<VkDeviceSize>( size ), |
| static_cast<VkIndexType>( indexType ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::getRenderingAreaGranularityKHR( const VULKAN_HPP_NAMESPACE::RenderingAreaInfoKHR * pRenderingAreaInfo, |
| VULKAN_HPP_NAMESPACE::Extent2D * pGranularity, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetRenderingAreaGranularityKHR( |
| m_device, reinterpret_cast<const VkRenderingAreaInfoKHR *>( pRenderingAreaInfo ), reinterpret_cast<VkExtent2D *>( pGranularity ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Extent2D |
| Device::getRenderingAreaGranularityKHR( const VULKAN_HPP_NAMESPACE::RenderingAreaInfoKHR & renderingAreaInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetRenderingAreaGranularityKHR && "Function <vkGetRenderingAreaGranularityKHR> requires <VK_KHR_maintenance5>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Extent2D granularity; |
| d.vkGetRenderingAreaGranularityKHR( |
| m_device, reinterpret_cast<const VkRenderingAreaInfoKHR *>( &renderingAreaInfo ), reinterpret_cast<VkExtent2D *>( &granularity ) ); |
| |
| return granularity; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::getImageSubresourceLayoutKHR( const VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfoKHR * pInfo, |
| VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR * pLayout, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetDeviceImageSubresourceLayoutKHR( |
| m_device, reinterpret_cast<const VkDeviceImageSubresourceInfoKHR *>( pInfo ), reinterpret_cast<VkSubresourceLayout2KHR *>( pLayout ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR |
| Device::getImageSubresourceLayoutKHR( const VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfoKHR & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetDeviceImageSubresourceLayoutKHR && "Function <vkGetDeviceImageSubresourceLayoutKHR> requires <VK_KHR_maintenance5>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR layout; |
| d.vkGetDeviceImageSubresourceLayoutKHR( |
| m_device, reinterpret_cast<const VkDeviceImageSubresourceInfoKHR *>( &info ), reinterpret_cast<VkSubresourceLayout2KHR *>( &layout ) ); |
| |
| return layout; |
| } |
| |
| template <typename X, typename Y, typename... Z, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> |
| Device::getImageSubresourceLayoutKHR( const VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfoKHR & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetDeviceImageSubresourceLayoutKHR && "Function <vkGetDeviceImageSubresourceLayoutKHR> requires <VK_KHR_maintenance5>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain; |
| VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR & layout = structureChain.template get<VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR>(); |
| d.vkGetDeviceImageSubresourceLayoutKHR( |
| m_device, reinterpret_cast<const VkDeviceImageSubresourceInfoKHR *>( &info ), reinterpret_cast<VkSubresourceLayout2KHR *>( &layout ) ); |
| |
| return structureChain; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::getImageSubresourceLayout2KHR( VULKAN_HPP_NAMESPACE::Image image, |
| const VULKAN_HPP_NAMESPACE::ImageSubresource2KHR * pSubresource, |
| VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR * pLayout, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetImageSubresourceLayout2KHR( m_device, |
| static_cast<VkImage>( image ), |
| reinterpret_cast<const VkImageSubresource2KHR *>( pSubresource ), |
| reinterpret_cast<VkSubresourceLayout2KHR *>( pLayout ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR Device::getImageSubresourceLayout2KHR( |
| VULKAN_HPP_NAMESPACE::Image image, const VULKAN_HPP_NAMESPACE::ImageSubresource2KHR & subresource, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( |
| d.vkGetImageSubresourceLayout2KHR && |
| "Function <vkGetImageSubresourceLayout2KHR> requires <VK_EXT_host_image_copy> or <VK_EXT_image_compression_control> or <VK_KHR_maintenance5>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR layout; |
| d.vkGetImageSubresourceLayout2KHR( m_device, |
| static_cast<VkImage>( image ), |
| reinterpret_cast<const VkImageSubresource2KHR *>( &subresource ), |
| reinterpret_cast<VkSubresourceLayout2KHR *>( &layout ) ); |
| |
| return layout; |
| } |
| |
| template <typename X, typename Y, typename... Z, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> Device::getImageSubresourceLayout2KHR( |
| VULKAN_HPP_NAMESPACE::Image image, const VULKAN_HPP_NAMESPACE::ImageSubresource2KHR & subresource, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( |
| d.vkGetImageSubresourceLayout2KHR && |
| "Function <vkGetImageSubresourceLayout2KHR> requires <VK_EXT_host_image_copy> or <VK_EXT_image_compression_control> or <VK_KHR_maintenance5>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain; |
| VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR & layout = structureChain.template get<VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR>(); |
| d.vkGetImageSubresourceLayout2KHR( m_device, |
| static_cast<VkImage>( image ), |
| reinterpret_cast<const VkImageSubresource2KHR *>( &subresource ), |
| reinterpret_cast<VkSubresourceLayout2KHR *>( &layout ) ); |
| |
| return structureChain; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_EXT_shader_object === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createShadersEXT( uint32_t createInfoCount, |
| const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT * pCreateInfos, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::ShaderEXT * pShaders, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateShadersEXT( m_device, |
| createInfoCount, |
| reinterpret_cast<const VkShaderCreateInfoEXT *>( pCreateInfos ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkShaderEXT *>( pShaders ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename ShaderEXTAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<VULKAN_HPP_NAMESPACE::ShaderEXT, ShaderEXTAllocator>> |
| Device::createShadersEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT> const & createInfos, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateShadersEXT && "Function <vkCreateShadersEXT> requires <VK_EXT_shader_object>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::ShaderEXT, ShaderEXTAllocator> shaders( createInfos.size() ); |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateShadersEXT( m_device, |
| createInfos.size(), |
| reinterpret_cast<const VkShaderCreateInfoEXT *>( createInfos.data() ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkShaderEXT *>( shaders.data() ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createShadersEXT", |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eIncompatibleShaderBinaryEXT } ); |
| |
| return ResultValue<std::vector<VULKAN_HPP_NAMESPACE::ShaderEXT, ShaderEXTAllocator>>( result, std::move( shaders ) ); |
| } |
| |
| template <typename ShaderEXTAllocator, |
| typename Dispatch, |
| typename std::enable_if<std::is_same<typename ShaderEXTAllocator::value_type, VULKAN_HPP_NAMESPACE::ShaderEXT>::value, int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<VULKAN_HPP_NAMESPACE::ShaderEXT, ShaderEXTAllocator>> |
| Device::createShadersEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT> const & createInfos, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| ShaderEXTAllocator & shaderEXTAllocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateShadersEXT && "Function <vkCreateShadersEXT> requires <VK_EXT_shader_object>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::ShaderEXT, ShaderEXTAllocator> shaders( createInfos.size(), shaderEXTAllocator ); |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateShadersEXT( m_device, |
| createInfos.size(), |
| reinterpret_cast<const VkShaderCreateInfoEXT *>( createInfos.data() ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkShaderEXT *>( shaders.data() ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createShadersEXT", |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eIncompatibleShaderBinaryEXT } ); |
| |
| return ResultValue<std::vector<VULKAN_HPP_NAMESPACE::ShaderEXT, ShaderEXTAllocator>>( result, std::move( shaders ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<VULKAN_HPP_NAMESPACE::ShaderEXT> |
| Device::createShaderEXT( const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateShadersEXT && "Function <vkCreateShadersEXT> requires <VK_EXT_shader_object>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::ShaderEXT shader; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateShadersEXT( m_device, |
| 1, |
| reinterpret_cast<const VkShaderCreateInfoEXT *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkShaderEXT *>( &shader ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createShaderEXT", |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eIncompatibleShaderBinaryEXT } ); |
| |
| return ResultValue<VULKAN_HPP_NAMESPACE::ShaderEXT>( result, std::move( shader ) ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch, typename ShaderEXTAllocator> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>, ShaderEXTAllocator>> |
| Device::createShadersEXTUnique( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT> const & createInfos, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateShadersEXT && "Function <vkCreateShadersEXT> requires <VK_EXT_shader_object>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::ShaderEXT> shaders( createInfos.size() ); |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateShadersEXT( m_device, |
| createInfos.size(), |
| reinterpret_cast<const VkShaderCreateInfoEXT *>( createInfos.data() ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkShaderEXT *>( shaders.data() ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createShadersEXTUnique", |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eIncompatibleShaderBinaryEXT } ); |
| std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>, ShaderEXTAllocator> uniqueShaders; |
| uniqueShaders.reserve( createInfos.size() ); |
| ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d ); |
| for ( auto const & shader : shaders ) |
| { |
| uniqueShaders.push_back( UniqueHandle<ShaderEXT, Dispatch>( shader, deleter ) ); |
| } |
| return ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>, ShaderEXTAllocator>>( result, std::move( uniqueShaders ) ); |
| } |
| |
| template < |
| typename Dispatch, |
| typename ShaderEXTAllocator, |
| typename std::enable_if<std::is_same<typename ShaderEXTAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>>::value, int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>, ShaderEXTAllocator>> |
| Device::createShadersEXTUnique( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT> const & createInfos, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| ShaderEXTAllocator & shaderEXTAllocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateShadersEXT && "Function <vkCreateShadersEXT> requires <VK_EXT_shader_object>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::ShaderEXT> shaders( createInfos.size() ); |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateShadersEXT( m_device, |
| createInfos.size(), |
| reinterpret_cast<const VkShaderCreateInfoEXT *>( createInfos.data() ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkShaderEXT *>( shaders.data() ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createShadersEXTUnique", |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eIncompatibleShaderBinaryEXT } ); |
| std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>, ShaderEXTAllocator> uniqueShaders( shaderEXTAllocator ); |
| uniqueShaders.reserve( createInfos.size() ); |
| ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d ); |
| for ( auto const & shader : shaders ) |
| { |
| uniqueShaders.push_back( UniqueHandle<ShaderEXT, Dispatch>( shader, deleter ) ); |
| } |
| return ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>, ShaderEXTAllocator>>( result, std::move( uniqueShaders ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>> |
| Device::createShaderEXTUnique( const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCreateShadersEXT && "Function <vkCreateShadersEXT> requires <VK_EXT_shader_object>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::ShaderEXT shader; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkCreateShadersEXT( m_device, |
| 1, |
| reinterpret_cast<const VkShaderCreateInfoEXT *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkShaderEXT *>( &shader ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createShaderEXTUnique", |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eIncompatibleShaderBinaryEXT } ); |
| |
| return ResultValue<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>>( |
| result, UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>( shader, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) ); |
| } |
| # endif /* VULKAN_HPP_NO_SMART_HANDLE */ |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyShaderEXT( VULKAN_HPP_NAMESPACE::ShaderEXT shader, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyShaderEXT( m_device, static_cast<VkShaderEXT>( shader ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyShaderEXT( VULKAN_HPP_NAMESPACE::ShaderEXT shader, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyShaderEXT && "Function <vkDestroyShaderEXT> requires <VK_EXT_shader_object>" ); |
| # endif |
| |
| d.vkDestroyShaderEXT( m_device, |
| static_cast<VkShaderEXT>( shader ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::ShaderEXT shader, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyShaderEXT( m_device, static_cast<VkShaderEXT>( shader ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::ShaderEXT shader, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkDestroyShaderEXT && "Function <vkDestroyShaderEXT> requires <VK_EXT_shader_object>" ); |
| # endif |
| |
| d.vkDestroyShaderEXT( m_device, |
| static_cast<VkShaderEXT>( shader ), |
| reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| Device::getShaderBinaryDataEXT( VULKAN_HPP_NAMESPACE::ShaderEXT shader, size_t * pDataSize, void * pData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetShaderBinaryDataEXT( m_device, static_cast<VkShaderEXT>( shader ), pDataSize, pData ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Uint8_tAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type |
| Device::getShaderBinaryDataEXT( VULKAN_HPP_NAMESPACE::ShaderEXT shader, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetShaderBinaryDataEXT && "Function <vkGetShaderBinaryDataEXT> requires <VK_EXT_shader_object>" ); |
| # endif |
| |
| std::vector<uint8_t, Uint8_tAllocator> data; |
| size_t dataSize; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetShaderBinaryDataEXT( m_device, static_cast<VkShaderEXT>( shader ), &dataSize, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && dataSize ) |
| { |
| data.resize( dataSize ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetShaderBinaryDataEXT( m_device, static_cast<VkShaderEXT>( shader ), &dataSize, reinterpret_cast<void *>( data.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getShaderBinaryDataEXT" ); |
| VULKAN_HPP_ASSERT( dataSize <= data.size() ); |
| if ( dataSize < data.size() ) |
| { |
| data.resize( dataSize ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); |
| } |
| |
| template <typename Uint8_tAllocator, |
| typename Dispatch, |
| typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type |
| Device::getShaderBinaryDataEXT( VULKAN_HPP_NAMESPACE::ShaderEXT shader, Uint8_tAllocator & uint8_tAllocator, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetShaderBinaryDataEXT && "Function <vkGetShaderBinaryDataEXT> requires <VK_EXT_shader_object>" ); |
| # endif |
| |
| std::vector<uint8_t, Uint8_tAllocator> data( uint8_tAllocator ); |
| size_t dataSize; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetShaderBinaryDataEXT( m_device, static_cast<VkShaderEXT>( shader ), &dataSize, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && dataSize ) |
| { |
| data.resize( dataSize ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetShaderBinaryDataEXT( m_device, static_cast<VkShaderEXT>( shader ), &dataSize, reinterpret_cast<void *>( data.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getShaderBinaryDataEXT" ); |
| VULKAN_HPP_ASSERT( dataSize <= data.size() ); |
| if ( dataSize < data.size() ) |
| { |
| data.resize( dataSize ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::bindShadersEXT( uint32_t stageCount, |
| const VULKAN_HPP_NAMESPACE::ShaderStageFlagBits * pStages, |
| const VULKAN_HPP_NAMESPACE::ShaderEXT * pShaders, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdBindShadersEXT( |
| m_commandBuffer, stageCount, reinterpret_cast<const VkShaderStageFlagBits *>( pStages ), reinterpret_cast<const VkShaderEXT *>( pShaders ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::bindShadersEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShaderStageFlagBits> const & stages, |
| VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShaderEXT> const & shaders, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdBindShadersEXT && "Function <vkCmdBindShadersEXT> requires <VK_EXT_shader_object>" ); |
| # endif |
| # ifdef VULKAN_HPP_NO_EXCEPTIONS |
| VULKAN_HPP_ASSERT( stages.size() == shaders.size() ); |
| # else |
| if ( stages.size() != shaders.size() ) |
| { |
| throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindShadersEXT: stages.size() != shaders.size()" ); |
| } |
| # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ |
| |
| d.vkCmdBindShadersEXT( m_commandBuffer, |
| stages.size(), |
| reinterpret_cast<const VkShaderStageFlagBits *>( stages.data() ), |
| reinterpret_cast<const VkShaderEXT *>( shaders.data() ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_QCOM_tile_properties === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getFramebufferTilePropertiesQCOM( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer, |
| uint32_t * pPropertiesCount, |
| VULKAN_HPP_NAMESPACE::TilePropertiesQCOM * pProperties, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetFramebufferTilePropertiesQCOM( |
| m_device, static_cast<VkFramebuffer>( framebuffer ), pPropertiesCount, reinterpret_cast<VkTilePropertiesQCOM *>( pProperties ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename TilePropertiesQCOMAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM, TilePropertiesQCOMAllocator>>::type |
| Device::getFramebufferTilePropertiesQCOM( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetFramebufferTilePropertiesQCOM && "Function <vkGetFramebufferTilePropertiesQCOM> requires <VK_QCOM_tile_properties>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM, TilePropertiesQCOMAllocator> properties; |
| uint32_t propertiesCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetFramebufferTilePropertiesQCOM( m_device, static_cast<VkFramebuffer>( framebuffer ), &propertiesCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertiesCount ) |
| { |
| properties.resize( propertiesCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetFramebufferTilePropertiesQCOM( |
| m_device, static_cast<VkFramebuffer>( framebuffer ), &propertiesCount, reinterpret_cast<VkTilePropertiesQCOM *>( properties.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| |
| VULKAN_HPP_ASSERT( propertiesCount <= properties.size() ); |
| if ( propertiesCount < properties.size() ) |
| { |
| properties.resize( propertiesCount ); |
| } |
| return properties; |
| } |
| |
| template <typename TilePropertiesQCOMAllocator, |
| typename Dispatch, |
| typename std::enable_if<std::is_same<typename TilePropertiesQCOMAllocator::value_type, VULKAN_HPP_NAMESPACE::TilePropertiesQCOM>::value, int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM, TilePropertiesQCOMAllocator>>::type |
| Device::getFramebufferTilePropertiesQCOM( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer, |
| TilePropertiesQCOMAllocator & tilePropertiesQCOMAllocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetFramebufferTilePropertiesQCOM && "Function <vkGetFramebufferTilePropertiesQCOM> requires <VK_QCOM_tile_properties>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM, TilePropertiesQCOMAllocator> properties( tilePropertiesQCOMAllocator ); |
| uint32_t propertiesCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetFramebufferTilePropertiesQCOM( m_device, static_cast<VkFramebuffer>( framebuffer ), &propertiesCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertiesCount ) |
| { |
| properties.resize( propertiesCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetFramebufferTilePropertiesQCOM( |
| m_device, static_cast<VkFramebuffer>( framebuffer ), &propertiesCount, reinterpret_cast<VkTilePropertiesQCOM *>( properties.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| |
| VULKAN_HPP_ASSERT( propertiesCount <= properties.size() ); |
| if ( propertiesCount < properties.size() ) |
| { |
| properties.resize( propertiesCount ); |
| } |
| return properties; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE Result Device::getDynamicRenderingTilePropertiesQCOM( const VULKAN_HPP_NAMESPACE::RenderingInfo * pRenderingInfo, |
| VULKAN_HPP_NAMESPACE::TilePropertiesQCOM * pProperties, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetDynamicRenderingTilePropertiesQCOM( |
| m_device, reinterpret_cast<const VkRenderingInfo *>( pRenderingInfo ), reinterpret_cast<VkTilePropertiesQCOM *>( pProperties ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::TilePropertiesQCOM |
| Device::getDynamicRenderingTilePropertiesQCOM( const VULKAN_HPP_NAMESPACE::RenderingInfo & renderingInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetDynamicRenderingTilePropertiesQCOM && "Function <vkGetDynamicRenderingTilePropertiesQCOM> requires <VK_QCOM_tile_properties>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::TilePropertiesQCOM properties; |
| d.vkGetDynamicRenderingTilePropertiesQCOM( |
| m_device, reinterpret_cast<const VkRenderingInfo *>( &renderingInfo ), reinterpret_cast<VkTilePropertiesQCOM *>( &properties ) ); |
| |
| return properties; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_NV_low_latency2 === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::setLatencySleepModeNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, |
| const VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV * pSleepModeInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( |
| d.vkSetLatencySleepModeNV( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<const VkLatencySleepModeInfoNV *>( pSleepModeInfo ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::setLatencySleepModeNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, |
| const VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV & sleepModeInfo, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkSetLatencySleepModeNV && "Function <vkSetLatencySleepModeNV> requires <VK_NV_low_latency2>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkSetLatencySleepModeNV( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<const VkLatencySleepModeInfoNV *>( &sleepModeInfo ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setLatencySleepModeNV" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE Result Device::latencySleepNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, |
| const VULKAN_HPP_NAMESPACE::LatencySleepInfoNV * pSleepInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( |
| d.vkLatencySleepNV( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<const VkLatencySleepInfoNV *>( pSleepInfo ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::latencySleepNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, |
| const VULKAN_HPP_NAMESPACE::LatencySleepInfoNV & sleepInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkLatencySleepNV && "Function <vkLatencySleepNV> requires <VK_NV_low_latency2>" ); |
| # endif |
| |
| d.vkLatencySleepNV( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<const VkLatencySleepInfoNV *>( &sleepInfo ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::setLatencyMarkerNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, |
| const VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV * pLatencyMarkerInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkSetLatencyMarkerNV( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<const VkSetLatencyMarkerInfoNV *>( pLatencyMarkerInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::setLatencyMarkerNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, |
| const VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV & latencyMarkerInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkSetLatencyMarkerNV && "Function <vkSetLatencyMarkerNV> requires <VK_NV_low_latency2>" ); |
| # endif |
| |
| d.vkSetLatencyMarkerNV( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<const VkSetLatencyMarkerInfoNV *>( &latencyMarkerInfo ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::getLatencyTimingsNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, |
| VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV * pLatencyMarkerInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetLatencyTimingsNV( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<VkGetLatencyMarkerInfoNV *>( pLatencyMarkerInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV |
| Device::getLatencyTimingsNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetLatencyTimingsNV && "Function <vkGetLatencyTimingsNV> requires <VK_NV_low_latency2>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV latencyMarkerInfo; |
| d.vkGetLatencyTimingsNV( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<VkGetLatencyMarkerInfoNV *>( &latencyMarkerInfo ) ); |
| |
| return latencyMarkerInfo; |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Queue::notifyOutOfBandNV( const VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeInfoNV * pQueueTypeInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkQueueNotifyOutOfBandNV( m_queue, reinterpret_cast<const VkOutOfBandQueueTypeInfoNV *>( pQueueTypeInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Queue::notifyOutOfBandNV( const VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeInfoNV & queueTypeInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkQueueNotifyOutOfBandNV && "Function <vkQueueNotifyOutOfBandNV> requires <VK_NV_low_latency2>" ); |
| # endif |
| |
| d.vkQueueNotifyOutOfBandNV( m_queue, reinterpret_cast<const VkOutOfBandQueueTypeInfoNV *>( &queueTypeInfo ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_KHR_cooperative_matrix === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getCooperativeMatrixPropertiesKHR( |
| uint32_t * pPropertyCount, VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR * pProperties, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR( |
| m_physicalDevice, pPropertyCount, reinterpret_cast<VkCooperativeMatrixPropertiesKHR *>( pProperties ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename CooperativeMatrixPropertiesKHRAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE |
| typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR, CooperativeMatrixPropertiesKHRAllocator>>::type |
| PhysicalDevice::getCooperativeMatrixPropertiesKHR( Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR && |
| "Function <vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR> requires <VK_KHR_cooperative_matrix>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR, CooperativeMatrixPropertiesKHRAllocator> properties; |
| uint32_t propertyCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR( m_physicalDevice, &propertyCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount ) |
| { |
| properties.resize( propertyCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR( |
| m_physicalDevice, &propertyCount, reinterpret_cast<VkCooperativeMatrixPropertiesKHR *>( properties.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCooperativeMatrixPropertiesKHR" ); |
| VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); |
| if ( propertyCount < properties.size() ) |
| { |
| properties.resize( propertyCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); |
| } |
| |
| template <typename CooperativeMatrixPropertiesKHRAllocator, |
| typename Dispatch, |
| typename std::enable_if< |
| std::is_same<typename CooperativeMatrixPropertiesKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR>::value, |
| int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE |
| typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR, CooperativeMatrixPropertiesKHRAllocator>>::type |
| PhysicalDevice::getCooperativeMatrixPropertiesKHR( CooperativeMatrixPropertiesKHRAllocator & cooperativeMatrixPropertiesKHRAllocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR && |
| "Function <vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR> requires <VK_KHR_cooperative_matrix>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR, CooperativeMatrixPropertiesKHRAllocator> properties( |
| cooperativeMatrixPropertiesKHRAllocator ); |
| uint32_t propertyCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR( m_physicalDevice, &propertyCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount ) |
| { |
| properties.resize( propertyCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR( |
| m_physicalDevice, &propertyCount, reinterpret_cast<VkCooperativeMatrixPropertiesKHR *>( properties.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCooperativeMatrixPropertiesKHR" ); |
| VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); |
| if ( propertyCount < properties.size() ) |
| { |
| properties.resize( propertyCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_EXT_attachment_feedback_loop_dynamic_state === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::setAttachmentFeedbackLoopEnableEXT( VULKAN_HPP_NAMESPACE::ImageAspectFlags aspectMask, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetAttachmentFeedbackLoopEnableEXT( m_commandBuffer, static_cast<VkImageAspectFlags>( aspectMask ) ); |
| } |
| |
| #if defined( VK_USE_PLATFORM_SCREEN_QNX ) |
| //=== VK_QNX_external_memory_screen_buffer === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getScreenBufferPropertiesQNX( const struct _screen_buffer * buffer, |
| VULKAN_HPP_NAMESPACE::ScreenBufferPropertiesQNX * pProperties, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetScreenBufferPropertiesQNX( m_device, buffer, reinterpret_cast<VkScreenBufferPropertiesQNX *>( pProperties ) ) ); |
| } |
| |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::ScreenBufferPropertiesQNX>::type |
| Device::getScreenBufferPropertiesQNX( const struct _screen_buffer & buffer, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetScreenBufferPropertiesQNX && "Function <vkGetScreenBufferPropertiesQNX> requires <VK_QNX_external_memory_screen_buffer>" ); |
| # endif |
| |
| VULKAN_HPP_NAMESPACE::ScreenBufferPropertiesQNX properties; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetScreenBufferPropertiesQNX( m_device, &buffer, reinterpret_cast<VkScreenBufferPropertiesQNX *>( &properties ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getScreenBufferPropertiesQNX" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); |
| } |
| |
| template <typename X, typename Y, typename... Z, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>>::type |
| Device::getScreenBufferPropertiesQNX( const struct _screen_buffer & buffer, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetScreenBufferPropertiesQNX && "Function <vkGetScreenBufferPropertiesQNX> requires <VK_QNX_external_memory_screen_buffer>" ); |
| # endif |
| |
| StructureChain<X, Y, Z...> structureChain; |
| VULKAN_HPP_NAMESPACE::ScreenBufferPropertiesQNX & properties = structureChain.template get<VULKAN_HPP_NAMESPACE::ScreenBufferPropertiesQNX>(); |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetScreenBufferPropertiesQNX( m_device, &buffer, reinterpret_cast<VkScreenBufferPropertiesQNX *>( &properties ) ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getScreenBufferPropertiesQNX" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( structureChain ) ); |
| } |
| # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| #endif /*VK_USE_PLATFORM_SCREEN_QNX*/ |
| |
| //=== VK_KHR_line_rasterization === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void |
| CommandBuffer::setLineStippleKHR( uint32_t lineStippleFactor, uint16_t lineStipplePattern, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetLineStippleKHR( m_commandBuffer, lineStippleFactor, lineStipplePattern ); |
| } |
| |
| //=== VK_KHR_calibrated_timestamps === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getCalibrateableTimeDomainsKHR( uint32_t * pTimeDomainCount, |
| VULKAN_HPP_NAMESPACE::TimeDomainKHR * pTimeDomains, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( |
| d.vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( m_physicalDevice, pTimeDomainCount, reinterpret_cast<VkTimeDomainKHR *>( pTimeDomains ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename TimeDomainKHRAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR, TimeDomainKHRAllocator>>::type |
| PhysicalDevice::getCalibrateableTimeDomainsKHR( Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceCalibrateableTimeDomainsKHR && |
| "Function <vkGetPhysicalDeviceCalibrateableTimeDomainsKHR> requires <VK_EXT_calibrated_timestamps> or <VK_KHR_calibrated_timestamps>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR, TimeDomainKHRAllocator> timeDomains; |
| uint32_t timeDomainCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( m_physicalDevice, &timeDomainCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && timeDomainCount ) |
| { |
| timeDomains.resize( timeDomainCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( m_physicalDevice, &timeDomainCount, reinterpret_cast<VkTimeDomainKHR *>( timeDomains.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCalibrateableTimeDomainsKHR" ); |
| VULKAN_HPP_ASSERT( timeDomainCount <= timeDomains.size() ); |
| if ( timeDomainCount < timeDomains.size() ) |
| { |
| timeDomains.resize( timeDomainCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( timeDomains ) ); |
| } |
| |
| template <typename TimeDomainKHRAllocator, |
| typename Dispatch, |
| typename std::enable_if<std::is_same<typename TimeDomainKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::TimeDomainKHR>::value, int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR, TimeDomainKHRAllocator>>::type |
| PhysicalDevice::getCalibrateableTimeDomainsKHR( TimeDomainKHRAllocator & timeDomainKHRAllocator, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceCalibrateableTimeDomainsKHR && |
| "Function <vkGetPhysicalDeviceCalibrateableTimeDomainsKHR> requires <VK_EXT_calibrated_timestamps> or <VK_KHR_calibrated_timestamps>" ); |
| # endif |
| |
| std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR, TimeDomainKHRAllocator> timeDomains( timeDomainKHRAllocator ); |
| uint32_t timeDomainCount; |
| VULKAN_HPP_NAMESPACE::Result result; |
| do |
| { |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( m_physicalDevice, &timeDomainCount, nullptr ) ); |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && timeDomainCount ) |
| { |
| timeDomains.resize( timeDomainCount ); |
| result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( m_physicalDevice, &timeDomainCount, reinterpret_cast<VkTimeDomainKHR *>( timeDomains.data() ) ) ); |
| } |
| } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCalibrateableTimeDomainsKHR" ); |
| VULKAN_HPP_ASSERT( timeDomainCount <= timeDomains.size() ); |
| if ( timeDomainCount < timeDomains.size() ) |
| { |
| timeDomains.resize( timeDomainCount ); |
| } |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( timeDomains ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getCalibratedTimestampsKHR( uint32_t timestampCount, |
| const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR * pTimestampInfos, |
| uint64_t * pTimestamps, |
| uint64_t * pMaxDeviation, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetCalibratedTimestampsKHR( |
| m_device, timestampCount, reinterpret_cast<const VkCalibratedTimestampInfoKHR *>( pTimestampInfos ), pTimestamps, pMaxDeviation ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Uint64_tAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type |
| Device::getCalibratedTimestampsKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR> const & timestampInfos, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetCalibratedTimestampsKHR && |
| "Function <vkGetCalibratedTimestampsKHR> requires <VK_EXT_calibrated_timestamps> or <VK_KHR_calibrated_timestamps>" ); |
| # endif |
| |
| std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t> data_( |
| std::piecewise_construct, std::forward_as_tuple( timestampInfos.size() ), std::forward_as_tuple( 0 ) ); |
| std::vector<uint64_t, Uint64_tAllocator> & timestamps = data_.first; |
| uint64_t & maxDeviation = data_.second; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetCalibratedTimestampsKHR( |
| m_device, timestampInfos.size(), reinterpret_cast<const VkCalibratedTimestampInfoKHR *>( timestampInfos.data() ), timestamps.data(), &maxDeviation ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsKHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data_ ) ); |
| } |
| |
| template <typename Uint64_tAllocator, |
| typename Dispatch, |
| typename std::enable_if<std::is_same<typename Uint64_tAllocator::value_type, uint64_t>::value, int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type |
| Device::getCalibratedTimestampsKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR> const & timestampInfos, |
| Uint64_tAllocator & uint64_tAllocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetCalibratedTimestampsKHR && |
| "Function <vkGetCalibratedTimestampsKHR> requires <VK_EXT_calibrated_timestamps> or <VK_KHR_calibrated_timestamps>" ); |
| # endif |
| |
| std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t> data_( |
| std::piecewise_construct, std::forward_as_tuple( timestampInfos.size(), uint64_tAllocator ), std::forward_as_tuple( 0 ) ); |
| std::vector<uint64_t, Uint64_tAllocator> & timestamps = data_.first; |
| uint64_t & maxDeviation = data_.second; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetCalibratedTimestampsKHR( |
| m_device, timestampInfos.size(), reinterpret_cast<const VkCalibratedTimestampInfoKHR *>( timestampInfos.data() ), timestamps.data(), &maxDeviation ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsKHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data_ ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::pair<uint64_t, uint64_t>>::type |
| Device::getCalibratedTimestampKHR( const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR & timestampInfo, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkGetCalibratedTimestampsKHR && |
| "Function <vkGetCalibratedTimestampsKHR> requires <VK_EXT_calibrated_timestamps> or <VK_KHR_calibrated_timestamps>" ); |
| # endif |
| |
| std::pair<uint64_t, uint64_t> data_; |
| uint64_t & timestamp = data_.first; |
| uint64_t & maxDeviation = data_.second; |
| VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( |
| d.vkGetCalibratedTimestampsKHR( m_device, 1, reinterpret_cast<const VkCalibratedTimestampInfoKHR *>( ×tampInfo ), ×tamp, &maxDeviation ) ); |
| VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampKHR" ); |
| |
| return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data_ ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| //=== VK_KHR_maintenance6 === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorSets2KHR( const VULKAN_HPP_NAMESPACE::BindDescriptorSetsInfoKHR * pBindDescriptorSetsInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdBindDescriptorSets2KHR( m_commandBuffer, reinterpret_cast<const VkBindDescriptorSetsInfoKHR *>( pBindDescriptorSetsInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorSets2KHR( const VULKAN_HPP_NAMESPACE::BindDescriptorSetsInfoKHR & bindDescriptorSetsInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdBindDescriptorSets2KHR && "Function <vkCmdBindDescriptorSets2KHR> requires <VK_KHR_maintenance6>" ); |
| # endif |
| |
| d.vkCmdBindDescriptorSets2KHR( m_commandBuffer, reinterpret_cast<const VkBindDescriptorSetsInfoKHR *>( &bindDescriptorSetsInfo ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::pushConstants2KHR( const VULKAN_HPP_NAMESPACE::PushConstantsInfoKHR * pPushConstantsInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdPushConstants2KHR( m_commandBuffer, reinterpret_cast<const VkPushConstantsInfoKHR *>( pPushConstantsInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::pushConstants2KHR( const VULKAN_HPP_NAMESPACE::PushConstantsInfoKHR & pushConstantsInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdPushConstants2KHR && "Function <vkCmdPushConstants2KHR> requires <VK_KHR_maintenance6>" ); |
| # endif |
| |
| d.vkCmdPushConstants2KHR( m_commandBuffer, reinterpret_cast<const VkPushConstantsInfoKHR *>( &pushConstantsInfo ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSet2KHR( const VULKAN_HPP_NAMESPACE::PushDescriptorSetInfoKHR * pPushDescriptorSetInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdPushDescriptorSet2KHR( m_commandBuffer, reinterpret_cast<const VkPushDescriptorSetInfoKHR *>( pPushDescriptorSetInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSet2KHR( const VULKAN_HPP_NAMESPACE::PushDescriptorSetInfoKHR & pushDescriptorSetInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdPushDescriptorSet2KHR && "Function <vkCmdPushDescriptorSet2KHR> requires <VK_KHR_maintenance6>" ); |
| # endif |
| |
| d.vkCmdPushDescriptorSet2KHR( m_commandBuffer, reinterpret_cast<const VkPushDescriptorSetInfoKHR *>( &pushDescriptorSetInfo ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void |
| CommandBuffer::pushDescriptorSetWithTemplate2KHR( const VULKAN_HPP_NAMESPACE::PushDescriptorSetWithTemplateInfoKHR * pPushDescriptorSetWithTemplateInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdPushDescriptorSetWithTemplate2KHR( m_commandBuffer, |
| reinterpret_cast<const VkPushDescriptorSetWithTemplateInfoKHR *>( pPushDescriptorSetWithTemplateInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void |
| CommandBuffer::pushDescriptorSetWithTemplate2KHR( const VULKAN_HPP_NAMESPACE::PushDescriptorSetWithTemplateInfoKHR & pushDescriptorSetWithTemplateInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdPushDescriptorSetWithTemplate2KHR && "Function <vkCmdPushDescriptorSetWithTemplate2KHR> requires <VK_KHR_maintenance6>" ); |
| # endif |
| |
| d.vkCmdPushDescriptorSetWithTemplate2KHR( m_commandBuffer, |
| reinterpret_cast<const VkPushDescriptorSetWithTemplateInfoKHR *>( &pushDescriptorSetWithTemplateInfo ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void |
| CommandBuffer::setDescriptorBufferOffsets2EXT( const VULKAN_HPP_NAMESPACE::SetDescriptorBufferOffsetsInfoEXT * pSetDescriptorBufferOffsetsInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdSetDescriptorBufferOffsets2EXT( m_commandBuffer, reinterpret_cast<const VkSetDescriptorBufferOffsetsInfoEXT *>( pSetDescriptorBufferOffsetsInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void |
| CommandBuffer::setDescriptorBufferOffsets2EXT( const VULKAN_HPP_NAMESPACE::SetDescriptorBufferOffsetsInfoEXT & setDescriptorBufferOffsetsInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdSetDescriptorBufferOffsets2EXT && "Function <vkCmdSetDescriptorBufferOffsets2EXT> requires <VK_KHR_maintenance6>" ); |
| # endif |
| |
| d.vkCmdSetDescriptorBufferOffsets2EXT( m_commandBuffer, reinterpret_cast<const VkSetDescriptorBufferOffsetsInfoEXT *>( &setDescriptorBufferOffsetsInfo ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorBufferEmbeddedSamplers2EXT( |
| const VULKAN_HPP_NAMESPACE::BindDescriptorBufferEmbeddedSamplersInfoEXT * pBindDescriptorBufferEmbeddedSamplersInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkCmdBindDescriptorBufferEmbeddedSamplers2EXT( |
| m_commandBuffer, reinterpret_cast<const VkBindDescriptorBufferEmbeddedSamplersInfoEXT *>( pBindDescriptorBufferEmbeddedSamplersInfo ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorBufferEmbeddedSamplers2EXT( |
| const VULKAN_HPP_NAMESPACE::BindDescriptorBufferEmbeddedSamplersInfoEXT & bindDescriptorBufferEmbeddedSamplersInfo, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) |
| VULKAN_HPP_ASSERT( d.vkCmdBindDescriptorBufferEmbeddedSamplers2EXT && |
| "Function <vkCmdBindDescriptorBufferEmbeddedSamplers2EXT> requires <VK_KHR_maintenance6>" ); |
| # endif |
| |
| d.vkCmdBindDescriptorBufferEmbeddedSamplers2EXT( |
| m_commandBuffer, reinterpret_cast<const VkBindDescriptorBufferEmbeddedSamplersInfoEXT *>( &bindDescriptorBufferEmbeddedSamplersInfo ) ); |
| } |
| #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ |
| |
| } // namespace VULKAN_HPP_NAMESPACE |
| #endif |
