| // 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 |
| |
| // include-what-you-use: make sure, vulkan.hpp is used by code-completers |
| // IWYU pragma: private; include "vulkan.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( static_cast<VkInstance>( 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( static_cast<VkInstance>( 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( static_cast<VkPhysicalDevice>( 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( |
| static_cast<VkPhysicalDevice>( 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( static_cast<VkPhysicalDevice>( 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( static_cast<VkPhysicalDevice>( 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( |
| static_cast<VkPhysicalDevice>( 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( static_cast<VkPhysicalDevice>( 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( static_cast<VkInstance>( 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( static_cast<VkDevice>( 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( static_cast<VkPhysicalDevice>( 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( static_cast<VkDevice>( 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( |
| static_cast<VkPhysicalDevice>( 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( |
| static_cast<VkPhysicalDevice>( 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( static_cast<VkDevice>( 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( static_cast<VkQueue>( 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( static_cast<VkQueue>( 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( static_cast<VkDevice>( 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( static_cast<VkDevice>( 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( static_cast<VkDevice>( 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( static_cast<VkDevice>( 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( static_cast<VkDevice>( 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( static_cast<VkDevice>( 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( static_cast<VkDevice>( 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( static_cast<VkDevice>( 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( |
| static_cast<VkDevice>( 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( |
| static_cast<VkDevice>( 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( |
| static_cast<VkDevice>( 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( |
| static_cast<VkDevice>( 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( |
| static_cast<VkDevice>( 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( static_cast<VkDevice>( 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( static_cast<VkPhysicalDevice>( 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( |
| static_cast<VkQueue>( 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( static_cast<VkDevice>( 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( static_cast<VkDevice>( 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( static_cast<VkDevice>( 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( static_cast<VkDevice>( 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( static_cast<VkDevice>( 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( |
| static_cast<VkDevice>( 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( static_cast<VkDevice>( 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( |
| static_cast<VkDevice>( 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( |
| static_cast<VkDevice>( 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( static_cast<VkDevice>( 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( static_cast<VkDevice>( 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( static_cast<VkDevice>( 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( static_cast<VkDevice>( 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( static_cast<VkDevice>( 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( static_cast<VkDevice>( 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( static_cast<VkDevice>( 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( |
| static_cast<VkDevice>( 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( |
| static_cast<VkDevice>( 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( static_cast<VkDevice>( 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( static_cast<VkDevice>( 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( static_cast<VkDevice>( 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( static_cast<VkDevice>( 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( static_cast<VkDevice>( 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 |
|
