| // Copyright 2015-2021 The Khronos Group Inc. |
| // |
| // SPDX-License-Identifier: Apache-2.0 OR MIT |
| // |
| |
| // This header is generated from the Khronos Vulkan XML API Registry. |
| |
| #ifndef VULKAN_FUNCS_HPP |
| #define VULKAN_FUNCS_HPP |
| |
| namespace VULKAN_HPP_NAMESPACE |
| { |
| //=========================== |
| //=== COMMAND Definitions === |
| //=========================== |
| |
| //=== VK_VERSION_1_0 === |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| createInstance( const VULKAN_HPP_NAMESPACE::InstanceCreateInfo * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::Instance * pInstance, |
| Dispatch const & d ) VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateInstance( reinterpret_cast<const VkInstanceCreateInfo *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkInstance *>( pInstance ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS 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 ); |
| VULKAN_HPP_NAMESPACE::Instance instance; |
| Result result = static_cast<Result>( |
| d.vkCreateInstance( reinterpret_cast<const VkInstanceCreateInfo *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkInstance *>( &instance ) ) ); |
| return createResultValue( result, instance, VULKAN_HPP_NAMESPACE_STRING "::createInstance" ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS 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 ); |
| VULKAN_HPP_NAMESPACE::Instance instance; |
| Result result = static_cast<Result>( |
| d.vkCreateInstance( reinterpret_cast<const VkInstanceCreateInfo *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkInstance *>( &instance ) ) ); |
| ObjectDestroy<NoParent, Dispatch> deleter( allocator, d ); |
| return createResultValue<VULKAN_HPP_NAMESPACE::Instance, Dispatch>( |
| result, instance, VULKAN_HPP_NAMESPACE_STRING "::createInstanceUnique", deleter ); |
| } |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Instance::destroy( const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyInstance( m_instance, reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Instance::destroy( Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyInstance( m_instance, |
| reinterpret_cast<const VkAllocationCallbacks *>( |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| Instance::enumeratePhysicalDevices( uint32_t * pPhysicalDeviceCount, |
| VULKAN_HPP_NAMESPACE::PhysicalDevice * pPhysicalDevices, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkEnumeratePhysicalDevices( |
| m_instance, pPhysicalDeviceCount, reinterpret_cast<VkPhysicalDevice *>( pPhysicalDevices ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename PhysicalDeviceAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE |
| typename ResultValueType<std::vector<PhysicalDevice, PhysicalDeviceAllocator>>::type |
| Instance::enumeratePhysicalDevices( Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| std::vector<PhysicalDevice, PhysicalDeviceAllocator> physicalDevices; |
| uint32_t physicalDeviceCount; |
| Result result; |
| do |
| { |
| result = static_cast<Result>( d.vkEnumeratePhysicalDevices( m_instance, &physicalDeviceCount, nullptr ) ); |
| if ( ( result == Result::eSuccess ) && physicalDeviceCount ) |
| { |
| physicalDevices.resize( physicalDeviceCount ); |
| result = static_cast<Result>( d.vkEnumeratePhysicalDevices( |
| m_instance, &physicalDeviceCount, reinterpret_cast<VkPhysicalDevice *>( physicalDevices.data() ) ) ); |
| VULKAN_HPP_ASSERT( physicalDeviceCount <= physicalDevices.size() ); |
| } |
| } while ( result == Result::eIncomplete ); |
| if ( ( result == Result::eSuccess ) && ( physicalDeviceCount < physicalDevices.size() ) ) |
| { |
| physicalDevices.resize( physicalDeviceCount ); |
| } |
| return createResultValue( |
| result, physicalDevices, VULKAN_HPP_NAMESPACE_STRING "::Instance::enumeratePhysicalDevices" ); |
| } |
| |
| template <typename PhysicalDeviceAllocator, |
| typename Dispatch, |
| typename B, |
| typename std::enable_if<std::is_same<typename B::value_type, PhysicalDevice>::value, int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE |
| typename ResultValueType<std::vector<PhysicalDevice, PhysicalDeviceAllocator>>::type |
| Instance::enumeratePhysicalDevices( PhysicalDeviceAllocator & physicalDeviceAllocator, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| std::vector<PhysicalDevice, PhysicalDeviceAllocator> physicalDevices( physicalDeviceAllocator ); |
| uint32_t physicalDeviceCount; |
| Result result; |
| do |
| { |
| result = static_cast<Result>( d.vkEnumeratePhysicalDevices( m_instance, &physicalDeviceCount, nullptr ) ); |
| if ( ( result == Result::eSuccess ) && physicalDeviceCount ) |
| { |
| physicalDevices.resize( physicalDeviceCount ); |
| result = static_cast<Result>( d.vkEnumeratePhysicalDevices( |
| m_instance, &physicalDeviceCount, reinterpret_cast<VkPhysicalDevice *>( physicalDevices.data() ) ) ); |
| VULKAN_HPP_ASSERT( physicalDeviceCount <= physicalDevices.size() ); |
| } |
| } while ( result == Result::eIncomplete ); |
| if ( ( result == Result::eSuccess ) && ( physicalDeviceCount < physicalDevices.size() ) ) |
| { |
| physicalDevices.resize( physicalDeviceCount ); |
| } |
| return createResultValue( |
| result, physicalDevices, VULKAN_HPP_NAMESPACE_STRING "::Instance::enumeratePhysicalDevices" ); |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void PhysicalDevice::getFeatures( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures * pFeatures, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetPhysicalDeviceFeatures( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures *>( pFeatures ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures |
| PhysicalDevice::getFeatures( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures features; |
| d.vkGetPhysicalDeviceFeatures( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures *>( &features ) ); |
| return features; |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void |
| PhysicalDevice::getFormatProperties( VULKAN_HPP_NAMESPACE::Format format, |
| VULKAN_HPP_NAMESPACE::FormatProperties * pFormatProperties, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetPhysicalDeviceFormatProperties( |
| m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties *>( pFormatProperties ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::FormatProperties |
| PhysicalDevice::getFormatProperties( VULKAN_HPP_NAMESPACE::Format format, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| VULKAN_HPP_NAMESPACE::FormatProperties formatProperties; |
| d.vkGetPhysicalDeviceFormatProperties( |
| m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties *>( &formatProperties ) ); |
| return formatProperties; |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| PhysicalDevice::getImageFormatProperties( VULKAN_HPP_NAMESPACE::Format format, |
| VULKAN_HPP_NAMESPACE::ImageType type, |
| VULKAN_HPP_NAMESPACE::ImageTiling tiling, |
| VULKAN_HPP_NAMESPACE::ImageUsageFlags usage, |
| VULKAN_HPP_NAMESPACE::ImageCreateFlags flags, |
| VULKAN_HPP_NAMESPACE::ImageFormatProperties * pImageFormatProperties, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties( |
| m_physicalDevice, |
| static_cast<VkFormat>( format ), |
| static_cast<VkImageType>( type ), |
| static_cast<VkImageTiling>( tiling ), |
| static_cast<VkImageUsageFlags>( usage ), |
| static_cast<VkImageCreateFlags>( flags ), |
| reinterpret_cast<VkImageFormatProperties *>( pImageFormatProperties ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS 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 ); |
| VULKAN_HPP_NAMESPACE::ImageFormatProperties imageFormatProperties; |
| Result result = static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties( |
| m_physicalDevice, |
| static_cast<VkFormat>( format ), |
| static_cast<VkImageType>( type ), |
| static_cast<VkImageTiling>( tiling ), |
| static_cast<VkImageUsageFlags>( usage ), |
| static_cast<VkImageCreateFlags>( flags ), |
| reinterpret_cast<VkImageFormatProperties *>( &imageFormatProperties ) ) ); |
| return createResultValue( |
| result, imageFormatProperties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties" ); |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void PhysicalDevice::getProperties( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties * pProperties, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetPhysicalDeviceProperties( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties *>( pProperties ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties |
| PhysicalDevice::getProperties( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties properties; |
| d.vkGetPhysicalDeviceProperties( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties *>( &properties ) ); |
| return properties; |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void |
| PhysicalDevice::getQueueFamilyProperties( uint32_t * pQueueFamilyPropertyCount, |
| VULKAN_HPP_NAMESPACE::QueueFamilyProperties * pQueueFamilyProperties, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetPhysicalDeviceQueueFamilyProperties( m_physicalDevice, |
| pQueueFamilyPropertyCount, |
| reinterpret_cast<VkQueueFamilyProperties *>( pQueueFamilyProperties ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename QueueFamilyPropertiesAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<QueueFamilyProperties, QueueFamilyPropertiesAllocator> |
| PhysicalDevice::getQueueFamilyProperties( Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| std::vector<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() ); |
| return queueFamilyProperties; |
| } |
| |
| template <typename QueueFamilyPropertiesAllocator, |
| typename Dispatch, |
| typename B, |
| typename std::enable_if<std::is_same<typename B::value_type, QueueFamilyProperties>::value, int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<QueueFamilyProperties, QueueFamilyPropertiesAllocator> |
| PhysicalDevice::getQueueFamilyProperties( QueueFamilyPropertiesAllocator & queueFamilyPropertiesAllocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| std::vector<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() ); |
| return queueFamilyProperties; |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void |
| PhysicalDevice::getMemoryProperties( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties * pMemoryProperties, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetPhysicalDeviceMemoryProperties( m_physicalDevice, |
| reinterpret_cast<VkPhysicalDeviceMemoryProperties *>( pMemoryProperties ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties |
| PhysicalDevice::getMemoryProperties( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties memoryProperties; |
| d.vkGetPhysicalDeviceMemoryProperties( m_physicalDevice, |
| reinterpret_cast<VkPhysicalDeviceMemoryProperties *>( &memoryProperties ) ); |
| return memoryProperties; |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE PFN_vkVoidFunction Instance::getProcAddr( const char * pName, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return d.vkGetInstanceProcAddr( m_instance, pName ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE PFN_vkVoidFunction Instance::getProcAddr( const std::string & name, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return d.vkGetInstanceProcAddr( m_instance, name.c_str() ); |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE PFN_vkVoidFunction Device::getProcAddr( const char * pName, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return d.vkGetDeviceProcAddr( m_device, pName ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE PFN_vkVoidFunction Device::getProcAddr( const std::string & name, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return d.vkGetDeviceProcAddr( m_device, name.c_str() ); |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| PhysicalDevice::createDevice( const VULKAN_HPP_NAMESPACE::DeviceCreateInfo * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::Device * pDevice, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateDevice( m_physicalDevice, |
| reinterpret_cast<const VkDeviceCreateInfo *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkDevice *>( pDevice ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS 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 ); |
| VULKAN_HPP_NAMESPACE::Device device; |
| Result result = static_cast<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 ) ) ); |
| return createResultValue( result, device, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::createDevice" ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS 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 ); |
| VULKAN_HPP_NAMESPACE::Device device; |
| Result result = static_cast<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 ) ) ); |
| ObjectDestroy<NoParent, Dispatch> deleter( allocator, d ); |
| return createResultValue<VULKAN_HPP_NAMESPACE::Device, Dispatch>( |
| result, device, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::createDeviceUnique", deleter ); |
| } |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyDevice( m_device, reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| 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<ExtensionProperties, ExtensionPropertiesAllocator>>::type |
| enumerateInstanceExtensionProperties( Optional<const std::string> layerName, Dispatch const & d ) |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| std::vector<ExtensionProperties, ExtensionPropertiesAllocator> properties; |
| uint32_t propertyCount; |
| Result result; |
| do |
| { |
| result = static_cast<Result>( |
| d.vkEnumerateInstanceExtensionProperties( layerName ? layerName->c_str() : nullptr, &propertyCount, nullptr ) ); |
| if ( ( result == Result::eSuccess ) && propertyCount ) |
| { |
| properties.resize( propertyCount ); |
| result = static_cast<Result>( |
| d.vkEnumerateInstanceExtensionProperties( layerName ? layerName->c_str() : nullptr, |
| &propertyCount, |
| reinterpret_cast<VkExtensionProperties *>( properties.data() ) ) ); |
| VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); |
| } |
| } while ( result == Result::eIncomplete ); |
| if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) ) |
| { |
| properties.resize( propertyCount ); |
| } |
| return createResultValue( |
| result, properties, VULKAN_HPP_NAMESPACE_STRING "::enumerateInstanceExtensionProperties" ); |
| } |
| |
| template <typename ExtensionPropertiesAllocator, |
| typename Dispatch, |
| typename B, |
| typename std::enable_if<std::is_same<typename B::value_type, ExtensionProperties>::value, int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE |
| typename ResultValueType<std::vector<ExtensionProperties, ExtensionPropertiesAllocator>>::type |
| enumerateInstanceExtensionProperties( Optional<const std::string> layerName, |
| ExtensionPropertiesAllocator & extensionPropertiesAllocator, |
| Dispatch const & d ) |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| std::vector<ExtensionProperties, ExtensionPropertiesAllocator> properties( extensionPropertiesAllocator ); |
| uint32_t propertyCount; |
| Result result; |
| do |
| { |
| result = static_cast<Result>( |
| d.vkEnumerateInstanceExtensionProperties( layerName ? layerName->c_str() : nullptr, &propertyCount, nullptr ) ); |
| if ( ( result == Result::eSuccess ) && propertyCount ) |
| { |
| properties.resize( propertyCount ); |
| result = static_cast<Result>( |
| d.vkEnumerateInstanceExtensionProperties( layerName ? layerName->c_str() : nullptr, |
| &propertyCount, |
| reinterpret_cast<VkExtensionProperties *>( properties.data() ) ) ); |
| VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); |
| } |
| } while ( result == Result::eIncomplete ); |
| if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) ) |
| { |
| properties.resize( propertyCount ); |
| } |
| return createResultValue( |
| result, properties, VULKAN_HPP_NAMESPACE_STRING "::enumerateInstanceExtensionProperties" ); |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| PhysicalDevice::enumerateDeviceExtensionProperties( const char * pLayerName, |
| uint32_t * pPropertyCount, |
| VULKAN_HPP_NAMESPACE::ExtensionProperties * pProperties, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkEnumerateDeviceExtensionProperties( |
| m_physicalDevice, pLayerName, pPropertyCount, reinterpret_cast<VkExtensionProperties *>( pProperties ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename ExtensionPropertiesAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE |
| typename ResultValueType<std::vector<ExtensionProperties, ExtensionPropertiesAllocator>>::type |
| PhysicalDevice::enumerateDeviceExtensionProperties( Optional<const std::string> layerName, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| std::vector<ExtensionProperties, ExtensionPropertiesAllocator> properties; |
| uint32_t propertyCount; |
| Result result; |
| do |
| { |
| result = static_cast<Result>( d.vkEnumerateDeviceExtensionProperties( |
| m_physicalDevice, layerName ? layerName->c_str() : nullptr, &propertyCount, nullptr ) ); |
| if ( ( result == Result::eSuccess ) && propertyCount ) |
| { |
| properties.resize( propertyCount ); |
| result = static_cast<Result>( |
| d.vkEnumerateDeviceExtensionProperties( m_physicalDevice, |
| layerName ? layerName->c_str() : nullptr, |
| &propertyCount, |
| reinterpret_cast<VkExtensionProperties *>( properties.data() ) ) ); |
| VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); |
| } |
| } while ( result == Result::eIncomplete ); |
| if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) ) |
| { |
| properties.resize( propertyCount ); |
| } |
| return createResultValue( |
| result, properties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateDeviceExtensionProperties" ); |
| } |
| |
| template <typename ExtensionPropertiesAllocator, |
| typename Dispatch, |
| typename B, |
| typename std::enable_if<std::is_same<typename B::value_type, ExtensionProperties>::value, int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE |
| typename ResultValueType<std::vector<ExtensionProperties, ExtensionPropertiesAllocator>>::type |
| PhysicalDevice::enumerateDeviceExtensionProperties( Optional<const std::string> layerName, |
| ExtensionPropertiesAllocator & extensionPropertiesAllocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| std::vector<ExtensionProperties, ExtensionPropertiesAllocator> properties( extensionPropertiesAllocator ); |
| uint32_t propertyCount; |
| Result result; |
| do |
| { |
| result = static_cast<Result>( d.vkEnumerateDeviceExtensionProperties( |
| m_physicalDevice, layerName ? layerName->c_str() : nullptr, &propertyCount, nullptr ) ); |
| if ( ( result == Result::eSuccess ) && propertyCount ) |
| { |
| properties.resize( propertyCount ); |
| result = static_cast<Result>( |
| d.vkEnumerateDeviceExtensionProperties( m_physicalDevice, |
| layerName ? layerName->c_str() : nullptr, |
| &propertyCount, |
| reinterpret_cast<VkExtensionProperties *>( properties.data() ) ) ); |
| VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); |
| } |
| } while ( result == Result::eIncomplete ); |
| if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) ) |
| { |
| properties.resize( propertyCount ); |
| } |
| return createResultValue( |
| result, properties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateDeviceExtensionProperties" ); |
| } |
| #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<LayerProperties, LayerPropertiesAllocator>>::type |
| enumerateInstanceLayerProperties( Dispatch const & d ) |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| std::vector<LayerProperties, LayerPropertiesAllocator> properties; |
| uint32_t propertyCount; |
| Result result; |
| do |
| { |
| result = static_cast<Result>( d.vkEnumerateInstanceLayerProperties( &propertyCount, nullptr ) ); |
| if ( ( result == Result::eSuccess ) && propertyCount ) |
| { |
| properties.resize( propertyCount ); |
| result = static_cast<Result>( d.vkEnumerateInstanceLayerProperties( |
| &propertyCount, reinterpret_cast<VkLayerProperties *>( properties.data() ) ) ); |
| VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); |
| } |
| } while ( result == Result::eIncomplete ); |
| if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) ) |
| { |
| properties.resize( propertyCount ); |
| } |
| return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING "::enumerateInstanceLayerProperties" ); |
| } |
| |
| template <typename LayerPropertiesAllocator, |
| typename Dispatch, |
| typename B, |
| typename std::enable_if<std::is_same<typename B::value_type, LayerProperties>::value, int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE |
| typename ResultValueType<std::vector<LayerProperties, LayerPropertiesAllocator>>::type |
| enumerateInstanceLayerProperties( LayerPropertiesAllocator & layerPropertiesAllocator, Dispatch const & d ) |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| std::vector<LayerProperties, LayerPropertiesAllocator> properties( layerPropertiesAllocator ); |
| uint32_t propertyCount; |
| Result result; |
| do |
| { |
| result = static_cast<Result>( d.vkEnumerateInstanceLayerProperties( &propertyCount, nullptr ) ); |
| if ( ( result == Result::eSuccess ) && propertyCount ) |
| { |
| properties.resize( propertyCount ); |
| result = static_cast<Result>( d.vkEnumerateInstanceLayerProperties( |
| &propertyCount, reinterpret_cast<VkLayerProperties *>( properties.data() ) ) ); |
| VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); |
| } |
| } while ( result == Result::eIncomplete ); |
| if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) ) |
| { |
| properties.resize( propertyCount ); |
| } |
| return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING "::enumerateInstanceLayerProperties" ); |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| PhysicalDevice::enumerateDeviceLayerProperties( uint32_t * pPropertyCount, |
| VULKAN_HPP_NAMESPACE::LayerProperties * pProperties, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkEnumerateDeviceLayerProperties( |
| m_physicalDevice, pPropertyCount, reinterpret_cast<VkLayerProperties *>( pProperties ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename LayerPropertiesAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE |
| typename ResultValueType<std::vector<LayerProperties, LayerPropertiesAllocator>>::type |
| PhysicalDevice::enumerateDeviceLayerProperties( Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| std::vector<LayerProperties, LayerPropertiesAllocator> properties; |
| uint32_t propertyCount; |
| Result result; |
| do |
| { |
| result = static_cast<Result>( d.vkEnumerateDeviceLayerProperties( m_physicalDevice, &propertyCount, nullptr ) ); |
| if ( ( result == Result::eSuccess ) && propertyCount ) |
| { |
| properties.resize( propertyCount ); |
| result = static_cast<Result>( d.vkEnumerateDeviceLayerProperties( |
| m_physicalDevice, &propertyCount, reinterpret_cast<VkLayerProperties *>( properties.data() ) ) ); |
| VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); |
| } |
| } while ( result == Result::eIncomplete ); |
| if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) ) |
| { |
| properties.resize( propertyCount ); |
| } |
| return createResultValue( |
| result, properties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateDeviceLayerProperties" ); |
| } |
| |
| template <typename LayerPropertiesAllocator, |
| typename Dispatch, |
| typename B, |
| typename std::enable_if<std::is_same<typename B::value_type, LayerProperties>::value, int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE |
| typename ResultValueType<std::vector<LayerProperties, LayerPropertiesAllocator>>::type |
| PhysicalDevice::enumerateDeviceLayerProperties( LayerPropertiesAllocator & layerPropertiesAllocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| std::vector<LayerProperties, LayerPropertiesAllocator> properties( layerPropertiesAllocator ); |
| uint32_t propertyCount; |
| Result result; |
| do |
| { |
| result = static_cast<Result>( d.vkEnumerateDeviceLayerProperties( m_physicalDevice, &propertyCount, nullptr ) ); |
| if ( ( result == Result::eSuccess ) && propertyCount ) |
| { |
| properties.resize( propertyCount ); |
| result = static_cast<Result>( d.vkEnumerateDeviceLayerProperties( |
| m_physicalDevice, &propertyCount, reinterpret_cast<VkLayerProperties *>( properties.data() ) ) ); |
| VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); |
| } |
| } while ( result == Result::eIncomplete ); |
| if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) ) |
| { |
| properties.resize( propertyCount ); |
| } |
| return createResultValue( |
| result, properties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateDeviceLayerProperties" ); |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::getQueue( uint32_t queueFamilyIndex, |
| uint32_t queueIndex, |
| VULKAN_HPP_NAMESPACE::Queue * pQueue, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetDeviceQueue( m_device, queueFamilyIndex, queueIndex, reinterpret_cast<VkQueue *>( pQueue ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Queue |
| Device::getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| VULKAN_HPP_NAMESPACE::Queue queue; |
| d.vkGetDeviceQueue( m_device, queueFamilyIndex, queueIndex, reinterpret_cast<VkQueue *>( &queue ) ); |
| return queue; |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Queue::submit( uint32_t submitCount, |
| const VULKAN_HPP_NAMESPACE::SubmitInfo * pSubmits, |
| VULKAN_HPP_NAMESPACE::Fence fence, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkQueueSubmit( |
| m_queue, submitCount, reinterpret_cast<const VkSubmitInfo *>( pSubmits ), static_cast<VkFence>( fence ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type |
| Queue::submit( 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 ); |
| Result result = static_cast<Result>( d.vkQueueSubmit( m_queue, |
| submits.size(), |
| reinterpret_cast<const VkSubmitInfo *>( submits.data() ), |
| static_cast<VkFence>( fence ) ) ); |
| return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::submit" ); |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Queue::waitIdle( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkQueueWaitIdle( m_queue ) ); |
| } |
| #else |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type |
| Queue::waitIdle( Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| Result result = static_cast<Result>( d.vkQueueWaitIdle( m_queue ) ); |
| return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::waitIdle" ); |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::waitIdle( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkDeviceWaitIdle( m_device ) ); |
| } |
| #else |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type |
| Device::waitIdle( Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| Result result = static_cast<Result>( d.vkDeviceWaitIdle( m_device ) ); |
| return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::waitIdle" ); |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| Device::allocateMemory( const VULKAN_HPP_NAMESPACE::MemoryAllocateInfo * pAllocateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::DeviceMemory * pMemory, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkAllocateMemory( m_device, |
| reinterpret_cast<const VkMemoryAllocateInfo *>( pAllocateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkDeviceMemory *>( pMemory ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS 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 ); |
| VULKAN_HPP_NAMESPACE::DeviceMemory memory; |
| Result result = static_cast<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 ) ) ); |
| return createResultValue( result, memory, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateMemory" ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS 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 ); |
| VULKAN_HPP_NAMESPACE::DeviceMemory memory; |
| Result result = static_cast<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 ) ) ); |
| ObjectFree<Device, Dispatch> deleter( *this, allocator, d ); |
| return createResultValue<VULKAN_HPP_NAMESPACE::DeviceMemory, Dispatch>( |
| result, memory, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateMemoryUnique", deleter ); |
| } |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::freeMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkFreeMemory( |
| m_device, static_cast<VkDeviceMemory>( memory ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::freeMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkFreeMemory( m_device, |
| static_cast<VkDeviceMemory>( memory ), |
| reinterpret_cast<const VkAllocationCallbacks *>( |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::free( VULKAN_HPP_NAMESPACE::DeviceMemory memory, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkFreeMemory( |
| m_device, static_cast<VkDeviceMemory>( memory ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::free( VULKAN_HPP_NAMESPACE::DeviceMemory memory, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkFreeMemory( m_device, |
| static_cast<VkDeviceMemory>( memory ), |
| reinterpret_cast<const VkAllocationCallbacks *>( |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::mapMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory, |
| VULKAN_HPP_NAMESPACE::DeviceSize offset, |
| VULKAN_HPP_NAMESPACE::DeviceSize size, |
| VULKAN_HPP_NAMESPACE::MemoryMapFlags flags, |
| void ** ppData, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkMapMemory( m_device, |
| static_cast<VkDeviceMemory>( memory ), |
| static_cast<VkDeviceSize>( offset ), |
| static_cast<VkDeviceSize>( size ), |
| static_cast<VkMemoryMapFlags>( flags ), |
| ppData ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS 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 ); |
| void * pData; |
| Result result = static_cast<Result>( d.vkMapMemory( m_device, |
| static_cast<VkDeviceMemory>( memory ), |
| static_cast<VkDeviceSize>( offset ), |
| static_cast<VkDeviceSize>( size ), |
| static_cast<VkMemoryMapFlags>( flags ), |
| &pData ) ); |
| return createResultValue( result, pData, VULKAN_HPP_NAMESPACE_STRING "::Device::mapMemory" ); |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::unmapMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkUnmapMemory( m_device, static_cast<VkDeviceMemory>( memory ) ); |
| } |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| Device::flushMappedMemoryRanges( uint32_t memoryRangeCount, |
| const VULKAN_HPP_NAMESPACE::MappedMemoryRange * pMemoryRanges, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkFlushMappedMemoryRanges( |
| m_device, memoryRangeCount, reinterpret_cast<const VkMappedMemoryRange *>( pMemoryRanges ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type |
| Device::flushMappedMemoryRanges( ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const & memoryRanges, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| Result result = static_cast<Result>( d.vkFlushMappedMemoryRanges( |
| m_device, memoryRanges.size(), reinterpret_cast<const VkMappedMemoryRange *>( memoryRanges.data() ) ) ); |
| return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::flushMappedMemoryRanges" ); |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| Device::invalidateMappedMemoryRanges( uint32_t memoryRangeCount, |
| const VULKAN_HPP_NAMESPACE::MappedMemoryRange * pMemoryRanges, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkInvalidateMappedMemoryRanges( |
| m_device, memoryRangeCount, reinterpret_cast<const VkMappedMemoryRange *>( pMemoryRanges ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type |
| Device::invalidateMappedMemoryRanges( |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const & memoryRanges, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| Result result = static_cast<Result>( d.vkInvalidateMappedMemoryRanges( |
| m_device, memoryRanges.size(), reinterpret_cast<const VkMappedMemoryRange *>( memoryRanges.data() ) ) ); |
| return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::invalidateMappedMemoryRanges" ); |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::getMemoryCommitment( VULKAN_HPP_NAMESPACE::DeviceMemory memory, |
| VULKAN_HPP_NAMESPACE::DeviceSize * pCommittedMemoryInBytes, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetDeviceMemoryCommitment( |
| m_device, static_cast<VkDeviceMemory>( memory ), reinterpret_cast<VkDeviceSize *>( pCommittedMemoryInBytes ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceSize |
| Device::getMemoryCommitment( VULKAN_HPP_NAMESPACE::DeviceMemory memory, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| VULKAN_HPP_NAMESPACE::DeviceSize committedMemoryInBytes; |
| d.vkGetDeviceMemoryCommitment( |
| m_device, static_cast<VkDeviceMemory>( memory ), reinterpret_cast<VkDeviceSize *>( &committedMemoryInBytes ) ); |
| return committedMemoryInBytes; |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::bindBufferMemory( VULKAN_HPP_NAMESPACE::Buffer buffer, |
| VULKAN_HPP_NAMESPACE::DeviceMemory memory, |
| VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkBindBufferMemory( m_device, |
| static_cast<VkBuffer>( buffer ), |
| static_cast<VkDeviceMemory>( memory ), |
| static_cast<VkDeviceSize>( memoryOffset ) ) ); |
| } |
| #else |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type |
| Device::bindBufferMemory( VULKAN_HPP_NAMESPACE::Buffer buffer, |
| VULKAN_HPP_NAMESPACE::DeviceMemory memory, |
| VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| Result result = static_cast<Result>( d.vkBindBufferMemory( m_device, |
| static_cast<VkBuffer>( buffer ), |
| static_cast<VkDeviceMemory>( memory ), |
| static_cast<VkDeviceSize>( memoryOffset ) ) ); |
| return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindBufferMemory" ); |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::bindImageMemory( VULKAN_HPP_NAMESPACE::Image image, |
| VULKAN_HPP_NAMESPACE::DeviceMemory memory, |
| VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkBindImageMemory( m_device, |
| static_cast<VkImage>( image ), |
| static_cast<VkDeviceMemory>( memory ), |
| static_cast<VkDeviceSize>( memoryOffset ) ) ); |
| } |
| #else |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type |
| Device::bindImageMemory( VULKAN_HPP_NAMESPACE::Image image, |
| VULKAN_HPP_NAMESPACE::DeviceMemory memory, |
| VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| Result result = static_cast<Result>( d.vkBindImageMemory( m_device, |
| static_cast<VkImage>( image ), |
| static_cast<VkDeviceMemory>( memory ), |
| static_cast<VkDeviceSize>( memoryOffset ) ) ); |
| return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindImageMemory" ); |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void |
| Device::getBufferMemoryRequirements( VULKAN_HPP_NAMESPACE::Buffer buffer, |
| VULKAN_HPP_NAMESPACE::MemoryRequirements * pMemoryRequirements, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetBufferMemoryRequirements( |
| m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<VkMemoryRequirements *>( pMemoryRequirements ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements |
| Device::getBufferMemoryRequirements( VULKAN_HPP_NAMESPACE::Buffer buffer, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| VULKAN_HPP_NAMESPACE::MemoryRequirements memoryRequirements; |
| d.vkGetBufferMemoryRequirements( |
| m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<VkMemoryRequirements *>( &memoryRequirements ) ); |
| return memoryRequirements; |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void |
| Device::getImageMemoryRequirements( VULKAN_HPP_NAMESPACE::Image image, |
| VULKAN_HPP_NAMESPACE::MemoryRequirements * pMemoryRequirements, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetImageMemoryRequirements( |
| m_device, static_cast<VkImage>( image ), reinterpret_cast<VkMemoryRequirements *>( pMemoryRequirements ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements |
| Device::getImageMemoryRequirements( VULKAN_HPP_NAMESPACE::Image image, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| VULKAN_HPP_NAMESPACE::MemoryRequirements memoryRequirements; |
| d.vkGetImageMemoryRequirements( |
| m_device, static_cast<VkImage>( image ), reinterpret_cast<VkMemoryRequirements *>( &memoryRequirements ) ); |
| return memoryRequirements; |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirements( |
| VULKAN_HPP_NAMESPACE::Image image, |
| uint32_t * pSparseMemoryRequirementCount, |
| VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements * pSparseMemoryRequirements, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetImageSparseMemoryRequirements( |
| m_device, |
| static_cast<VkImage>( image ), |
| pSparseMemoryRequirementCount, |
| reinterpret_cast<VkSparseImageMemoryRequirements *>( pSparseMemoryRequirements ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename SparseImageMemoryRequirementsAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD |
| VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator> |
| Device::getImageSparseMemoryRequirements( VULKAN_HPP_NAMESPACE::Image image, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| std::vector<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() ); |
| return sparseMemoryRequirements; |
| } |
| |
| template < |
| typename SparseImageMemoryRequirementsAllocator, |
| typename Dispatch, |
| typename B, |
| typename std::enable_if<std::is_same<typename B::value_type, SparseImageMemoryRequirements>::value, int>::type> |
| VULKAN_HPP_NODISCARD |
| VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator> |
| Device::getImageSparseMemoryRequirements( |
| VULKAN_HPP_NAMESPACE::Image image, |
| SparseImageMemoryRequirementsAllocator & sparseImageMemoryRequirementsAllocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| std::vector<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() ); |
| return sparseMemoryRequirements; |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void |
| PhysicalDevice::getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format format, |
| VULKAN_HPP_NAMESPACE::ImageType type, |
| VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples, |
| VULKAN_HPP_NAMESPACE::ImageUsageFlags usage, |
| VULKAN_HPP_NAMESPACE::ImageTiling tiling, |
| uint32_t * pPropertyCount, |
| VULKAN_HPP_NAMESPACE::SparseImageFormatProperties * pProperties, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetPhysicalDeviceSparseImageFormatProperties( |
| m_physicalDevice, |
| static_cast<VkFormat>( format ), |
| static_cast<VkImageType>( type ), |
| static_cast<VkSampleCountFlagBits>( samples ), |
| static_cast<VkImageUsageFlags>( usage ), |
| static_cast<VkImageTiling>( tiling ), |
| pPropertyCount, |
| reinterpret_cast<VkSparseImageFormatProperties *>( pProperties ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename SparseImageFormatPropertiesAllocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<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 ); |
| std::vector<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() ); |
| return properties; |
| } |
| |
| template < |
| typename SparseImageFormatPropertiesAllocator, |
| typename Dispatch, |
| typename B, |
| typename std::enable_if<std::is_same<typename B::value_type, SparseImageFormatProperties>::value, int>::type> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<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 ); |
| std::vector<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() ); |
| return properties; |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| Queue::bindSparse( uint32_t bindInfoCount, |
| const VULKAN_HPP_NAMESPACE::BindSparseInfo * pBindInfo, |
| VULKAN_HPP_NAMESPACE::Fence fence, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkQueueBindSparse( m_queue, |
| bindInfoCount, |
| reinterpret_cast<const VkBindSparseInfo *>( pBindInfo ), |
| static_cast<VkFence>( fence ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type |
| Queue::bindSparse( 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 ); |
| Result result = |
| static_cast<Result>( d.vkQueueBindSparse( m_queue, |
| bindInfo.size(), |
| reinterpret_cast<const VkBindSparseInfo *>( bindInfo.data() ), |
| static_cast<VkFence>( fence ) ) ); |
| return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::bindSparse" ); |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| Device::createFence( const VULKAN_HPP_NAMESPACE::FenceCreateInfo * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::Fence * pFence, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateFence( m_device, |
| reinterpret_cast<const VkFenceCreateInfo *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkFence *>( pFence ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS 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 ); |
| VULKAN_HPP_NAMESPACE::Fence fence; |
| Result result = static_cast<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 ) ) ); |
| return createResultValue( result, fence, VULKAN_HPP_NAMESPACE_STRING "::Device::createFence" ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS 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 ); |
| VULKAN_HPP_NAMESPACE::Fence fence; |
| Result result = static_cast<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 ) ) ); |
| ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d ); |
| return createResultValue<VULKAN_HPP_NAMESPACE::Fence, Dispatch>( |
| result, fence, VULKAN_HPP_NAMESPACE_STRING "::Device::createFenceUnique", deleter ); |
| } |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyFence( VULKAN_HPP_NAMESPACE::Fence fence, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyFence( |
| m_device, static_cast<VkFence>( fence ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyFence( VULKAN_HPP_NAMESPACE::Fence fence, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyFence( m_device, |
| static_cast<VkFence>( fence ), |
| reinterpret_cast<const VkAllocationCallbacks *>( |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Fence fence, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyFence( |
| m_device, static_cast<VkFence>( fence ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Fence fence, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyFence( m_device, |
| static_cast<VkFence>( fence ), |
| reinterpret_cast<const VkAllocationCallbacks *>( |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::resetFences( uint32_t fenceCount, |
| const VULKAN_HPP_NAMESPACE::Fence * pFences, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkResetFences( m_device, fenceCount, reinterpret_cast<const VkFence *>( pFences ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE typename ResultValueType<void>::type |
| Device::resetFences( ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const & fences, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| Result result = static_cast<Result>( |
| d.vkResetFences( m_device, fences.size(), reinterpret_cast<const VkFence *>( fences.data() ) ) ); |
| return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::resetFences" ); |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getFenceStatus( VULKAN_HPP_NAMESPACE::Fence fence, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetFenceStatus( m_device, static_cast<VkFence>( fence ) ) ); |
| } |
| #else |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getFenceStatus( VULKAN_HPP_NAMESPACE::Fence fence, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| Result result = static_cast<Result>( d.vkGetFenceStatus( m_device, static_cast<VkFence>( fence ) ) ); |
| return createResultValue( result, |
| VULKAN_HPP_NAMESPACE_STRING "::Device::getFenceStatus", |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eNotReady } ); |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::waitForFences( uint32_t fenceCount, |
| const VULKAN_HPP_NAMESPACE::Fence * pFences, |
| VULKAN_HPP_NAMESPACE::Bool32 waitAll, |
| uint64_t timeout, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkWaitForFences( |
| m_device, fenceCount, reinterpret_cast<const VkFence *>( pFences ), static_cast<VkBool32>( waitAll ), timeout ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| Device::waitForFences( 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 ); |
| Result result = static_cast<Result>( d.vkWaitForFences( m_device, |
| fences.size(), |
| reinterpret_cast<const VkFence *>( fences.data() ), |
| static_cast<VkBool32>( waitAll ), |
| timeout ) ); |
| return createResultValue( result, |
| VULKAN_HPP_NAMESPACE_STRING "::Device::waitForFences", |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eTimeout } ); |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| Device::createSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::Semaphore * pSemaphore, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateSemaphore( m_device, |
| reinterpret_cast<const VkSemaphoreCreateInfo *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkSemaphore *>( pSemaphore ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS 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 ); |
| VULKAN_HPP_NAMESPACE::Semaphore semaphore; |
| Result result = static_cast<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 ) ) ); |
| return createResultValue( result, semaphore, VULKAN_HPP_NAMESPACE_STRING "::Device::createSemaphore" ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS 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 ); |
| VULKAN_HPP_NAMESPACE::Semaphore semaphore; |
| Result result = static_cast<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 ) ) ); |
| ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d ); |
| return createResultValue<VULKAN_HPP_NAMESPACE::Semaphore, Dispatch>( |
| result, semaphore, VULKAN_HPP_NAMESPACE_STRING "::Device::createSemaphoreUnique", deleter ); |
| } |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroySemaphore( VULKAN_HPP_NAMESPACE::Semaphore semaphore, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroySemaphore( |
| m_device, static_cast<VkSemaphore>( semaphore ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroySemaphore( VULKAN_HPP_NAMESPACE::Semaphore semaphore, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroySemaphore( m_device, |
| static_cast<VkSemaphore>( semaphore ), |
| reinterpret_cast<const VkAllocationCallbacks *>( |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Semaphore semaphore, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroySemaphore( |
| m_device, static_cast<VkSemaphore>( semaphore ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Semaphore semaphore, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroySemaphore( m_device, |
| static_cast<VkSemaphore>( semaphore ), |
| reinterpret_cast<const VkAllocationCallbacks *>( |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| Device::createEvent( const VULKAN_HPP_NAMESPACE::EventCreateInfo * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::Event * pEvent, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateEvent( m_device, |
| reinterpret_cast<const VkEventCreateInfo *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkEvent *>( pEvent ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS 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 ); |
| VULKAN_HPP_NAMESPACE::Event event; |
| Result result = static_cast<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 ) ) ); |
| return createResultValue( result, event, VULKAN_HPP_NAMESPACE_STRING "::Device::createEvent" ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS 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 ); |
| VULKAN_HPP_NAMESPACE::Event event; |
| Result result = static_cast<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 ) ) ); |
| ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d ); |
| return createResultValue<VULKAN_HPP_NAMESPACE::Event, Dispatch>( |
| result, event, VULKAN_HPP_NAMESPACE_STRING "::Device::createEventUnique", deleter ); |
| } |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyEvent( VULKAN_HPP_NAMESPACE::Event event, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyEvent( |
| m_device, static_cast<VkEvent>( event ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyEvent( VULKAN_HPP_NAMESPACE::Event event, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyEvent( m_device, |
| static_cast<VkEvent>( event ), |
| reinterpret_cast<const VkAllocationCallbacks *>( |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Event event, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyEvent( |
| m_device, static_cast<VkEvent>( event ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Event event, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyEvent( m_device, |
| static_cast<VkEvent>( event ), |
| reinterpret_cast<const VkAllocationCallbacks *>( |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getEventStatus( VULKAN_HPP_NAMESPACE::Event event, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetEventStatus( m_device, static_cast<VkEvent>( event ) ) ); |
| } |
| #else |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getEventStatus( VULKAN_HPP_NAMESPACE::Event event, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| Result result = static_cast<Result>( d.vkGetEventStatus( m_device, static_cast<VkEvent>( event ) ) ); |
| return createResultValue( result, |
| VULKAN_HPP_NAMESPACE_STRING "::Device::getEventStatus", |
| { VULKAN_HPP_NAMESPACE::Result::eEventSet, VULKAN_HPP_NAMESPACE::Result::eEventReset } ); |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::setEvent( VULKAN_HPP_NAMESPACE::Event event, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkSetEvent( m_device, static_cast<VkEvent>( event ) ) ); |
| } |
| #else |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type |
| Device::setEvent( VULKAN_HPP_NAMESPACE::Event event, Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| Result result = static_cast<Result>( d.vkSetEvent( m_device, static_cast<VkEvent>( event ) ) ); |
| return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setEvent" ); |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::resetEvent( VULKAN_HPP_NAMESPACE::Event event, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkResetEvent( m_device, static_cast<VkEvent>( event ) ) ); |
| } |
| #else |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::resetEvent( VULKAN_HPP_NAMESPACE::Event event, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| Result result = static_cast<Result>( d.vkResetEvent( m_device, static_cast<VkEvent>( event ) ) ); |
| return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::resetEvent" ); |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| Device::createQueryPool( const VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::QueryPool * pQueryPool, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateQueryPool( m_device, |
| reinterpret_cast<const VkQueryPoolCreateInfo *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkQueryPool *>( pQueryPool ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS 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 ); |
| VULKAN_HPP_NAMESPACE::QueryPool queryPool; |
| Result result = static_cast<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 ) ) ); |
| return createResultValue( result, queryPool, VULKAN_HPP_NAMESPACE_STRING "::Device::createQueryPool" ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS 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 ); |
| VULKAN_HPP_NAMESPACE::QueryPool queryPool; |
| Result result = static_cast<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 ) ) ); |
| ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d ); |
| return createResultValue<VULKAN_HPP_NAMESPACE::QueryPool, Dispatch>( |
| result, queryPool, VULKAN_HPP_NAMESPACE_STRING "::Device::createQueryPoolUnique", deleter ); |
| } |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyQueryPool( |
| m_device, static_cast<VkQueryPool>( queryPool ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyQueryPool( m_device, |
| static_cast<VkQueryPool>( queryPool ), |
| reinterpret_cast<const VkAllocationCallbacks *>( |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::QueryPool queryPool, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyQueryPool( |
| m_device, static_cast<VkQueryPool>( queryPool ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::QueryPool queryPool, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyQueryPool( m_device, |
| static_cast<VkQueryPool>( queryPool ), |
| reinterpret_cast<const VkAllocationCallbacks *>( |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| Device::getQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool queryPool, |
| uint32_t firstQuery, |
| uint32_t queryCount, |
| size_t dataSize, |
| void * pData, |
| VULKAN_HPP_NAMESPACE::DeviceSize stride, |
| VULKAN_HPP_NAMESPACE::QueryResultFlags flags, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkGetQueryPoolResults( m_device, |
| static_cast<VkQueryPool>( queryPool ), |
| firstQuery, |
| queryCount, |
| dataSize, |
| pData, |
| static_cast<VkDeviceSize>( stride ), |
| static_cast<VkQueryResultFlags>( flags ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename T, typename Dispatch> |
| VULKAN_HPP_DEPRECATED( "This function is deprecated. Use one of the other flavours of it." ) |
| VULKAN_HPP_NODISCARD |
| VULKAN_HPP_INLINE Result Device::getQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool queryPool, |
| uint32_t firstQuery, |
| uint32_t queryCount, |
| ArrayProxy<T> const & data, |
| VULKAN_HPP_NAMESPACE::DeviceSize stride, |
| VULKAN_HPP_NAMESPACE::QueryResultFlags flags, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| Result result = static_cast<Result>( d.vkGetQueryPoolResults( m_device, |
| static_cast<VkQueryPool>( queryPool ), |
| firstQuery, |
| queryCount, |
| data.size() * sizeof( T ), |
| reinterpret_cast<void *>( data.data() ), |
| static_cast<VkDeviceSize>( stride ), |
| static_cast<VkQueryResultFlags>( flags ) ) ); |
| return createResultValue( result, |
| VULKAN_HPP_NAMESPACE_STRING "::Device::getQueryPoolResults", |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eNotReady } ); |
| } |
| |
| template <typename T, typename Allocator, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<T, Allocator>> |
| 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 ); |
| VULKAN_HPP_ASSERT( dataSize % sizeof( T ) == 0 ); |
| std::vector<T, Allocator> data( dataSize / sizeof( T ) ); |
| Result result = static_cast<Result>( d.vkGetQueryPoolResults( m_device, |
| static_cast<VkQueryPool>( queryPool ), |
| firstQuery, |
| queryCount, |
| data.size() * sizeof( T ), |
| reinterpret_cast<void *>( data.data() ), |
| static_cast<VkDeviceSize>( stride ), |
| static_cast<VkQueryResultFlags>( flags ) ) ); |
| return createResultValue( result, |
| data, |
| VULKAN_HPP_NAMESPACE_STRING "::Device::getQueryPoolResults", |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eNotReady } ); |
| } |
| |
| template <typename T, typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<T> |
| 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 ); |
| T data; |
| Result result = static_cast<Result>( d.vkGetQueryPoolResults( m_device, |
| static_cast<VkQueryPool>( queryPool ), |
| firstQuery, |
| queryCount, |
| sizeof( T ), |
| reinterpret_cast<void *>( &data ), |
| static_cast<VkDeviceSize>( stride ), |
| static_cast<VkQueryResultFlags>( flags ) ) ); |
| return createResultValue( result, |
| data, |
| VULKAN_HPP_NAMESPACE_STRING "::Device::getQueryPoolResult", |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eNotReady } ); |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| Device::createBuffer( const VULKAN_HPP_NAMESPACE::BufferCreateInfo * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::Buffer * pBuffer, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateBuffer( m_device, |
| reinterpret_cast<const VkBufferCreateInfo *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkBuffer *>( pBuffer ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS 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 ); |
| VULKAN_HPP_NAMESPACE::Buffer buffer; |
| Result result = static_cast<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 ) ) ); |
| return createResultValue( result, buffer, VULKAN_HPP_NAMESPACE_STRING "::Device::createBuffer" ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS 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 ); |
| VULKAN_HPP_NAMESPACE::Buffer buffer; |
| Result result = static_cast<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 ) ) ); |
| ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d ); |
| return createResultValue<VULKAN_HPP_NAMESPACE::Buffer, Dispatch>( |
| result, buffer, VULKAN_HPP_NAMESPACE_STRING "::Device::createBufferUnique", deleter ); |
| } |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyBuffer( VULKAN_HPP_NAMESPACE::Buffer buffer, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyBuffer( |
| m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyBuffer( VULKAN_HPP_NAMESPACE::Buffer buffer, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyBuffer( m_device, |
| static_cast<VkBuffer>( buffer ), |
| reinterpret_cast<const VkAllocationCallbacks *>( |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Buffer buffer, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyBuffer( |
| m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Buffer buffer, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyBuffer( m_device, |
| static_cast<VkBuffer>( buffer ), |
| reinterpret_cast<const VkAllocationCallbacks *>( |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| Device::createBufferView( const VULKAN_HPP_NAMESPACE::BufferViewCreateInfo * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::BufferView * pView, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateBufferView( m_device, |
| reinterpret_cast<const VkBufferViewCreateInfo *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkBufferView *>( pView ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS 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 ); |
| VULKAN_HPP_NAMESPACE::BufferView view; |
| Result result = static_cast<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 ) ) ); |
| return createResultValue( result, view, VULKAN_HPP_NAMESPACE_STRING "::Device::createBufferView" ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE |
| typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::BufferView, Dispatch>>::type |
| Device::createBufferViewUnique( const VULKAN_HPP_NAMESPACE::BufferViewCreateInfo & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| VULKAN_HPP_NAMESPACE::BufferView view; |
| Result result = static_cast<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 ) ) ); |
| ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d ); |
| return createResultValue<VULKAN_HPP_NAMESPACE::BufferView, Dispatch>( |
| result, view, VULKAN_HPP_NAMESPACE_STRING "::Device::createBufferViewUnique", deleter ); |
| } |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyBufferView( VULKAN_HPP_NAMESPACE::BufferView bufferView, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyBufferView( m_device, |
| static_cast<VkBufferView>( bufferView ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyBufferView( VULKAN_HPP_NAMESPACE::BufferView bufferView, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyBufferView( m_device, |
| static_cast<VkBufferView>( bufferView ), |
| reinterpret_cast<const VkAllocationCallbacks *>( |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::BufferView bufferView, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyBufferView( m_device, |
| static_cast<VkBufferView>( bufferView ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::BufferView bufferView, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyBufferView( m_device, |
| static_cast<VkBufferView>( bufferView ), |
| reinterpret_cast<const VkAllocationCallbacks *>( |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| Device::createImage( const VULKAN_HPP_NAMESPACE::ImageCreateInfo * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::Image * pImage, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateImage( m_device, |
| reinterpret_cast<const VkImageCreateInfo *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkImage *>( pImage ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::Image>::type |
| Device::createImage( const VULKAN_HPP_NAMESPACE::ImageCreateInfo & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| VULKAN_HPP_NAMESPACE::Image image; |
| Result result = static_cast<Result>( |
| d.vkCreateImage( m_device, |
| reinterpret_cast<const VkImageCreateInfo *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkImage *>( &image ) ) ); |
| return createResultValue( result, image, VULKAN_HPP_NAMESPACE_STRING "::Device::createImage" ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE |
| typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Image, Dispatch>>::type |
| Device::createImageUnique( const VULKAN_HPP_NAMESPACE::ImageCreateInfo & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| VULKAN_HPP_NAMESPACE::Image image; |
| Result result = static_cast<Result>( |
| d.vkCreateImage( m_device, |
| reinterpret_cast<const VkImageCreateInfo *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkImage *>( &image ) ) ); |
| ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d ); |
| return createResultValue<VULKAN_HPP_NAMESPACE::Image, Dispatch>( |
| result, image, VULKAN_HPP_NAMESPACE_STRING "::Device::createImageUnique", deleter ); |
| } |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyImage( VULKAN_HPP_NAMESPACE::Image image, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyImage( |
| m_device, static_cast<VkImage>( image ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroyImage( VULKAN_HPP_NAMESPACE::Image image, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyImage( m_device, |
| static_cast<VkImage>( image ), |
| reinterpret_cast<const VkAllocationCallbacks *>( |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Image image, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyImage( |
| m_device, static_cast<VkImage>( image ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Image image, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkDestroyImage( m_device, |
| static_cast<VkImage>( image ), |
| reinterpret_cast<const VkAllocationCallbacks *>( |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_INLINE void Device::getImageSubresourceLayout( VULKAN_HPP_NAMESPACE::Image image, |
| const VULKAN_HPP_NAMESPACE::ImageSubresource * pSubresource, |
| VULKAN_HPP_NAMESPACE::SubresourceLayout * pLayout, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| d.vkGetImageSubresourceLayout( m_device, |
| static_cast<VkImage>( image ), |
| reinterpret_cast<const VkImageSubresource *>( pSubresource ), |
| reinterpret_cast<VkSubresourceLayout *>( pLayout ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::SubresourceLayout |
| Device::getImageSubresourceLayout( VULKAN_HPP_NAMESPACE::Image image, |
| const VULKAN_HPP_NAMESPACE::ImageSubresource & subresource, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| VULKAN_HPP_NAMESPACE::SubresourceLayout layout; |
| d.vkGetImageSubresourceLayout( m_device, |
| static_cast<VkImage>( image ), |
| reinterpret_cast<const VkImageSubresource *>( &subresource ), |
| reinterpret_cast<VkSubresourceLayout *>( &layout ) ); |
| return layout; |
| } |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ |
| |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result |
| Device::createImageView( const VULKAN_HPP_NAMESPACE::ImageViewCreateInfo * pCreateInfo, |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, |
| VULKAN_HPP_NAMESPACE::ImageView * pView, |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| return static_cast<Result>( d.vkCreateImageView( m_device, |
| reinterpret_cast<const VkImageViewCreateInfo *>( pCreateInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), |
| reinterpret_cast<VkImageView *>( pView ) ) ); |
| } |
| |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE |
| typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageView>::type |
| Device::createImageView( const VULKAN_HPP_NAMESPACE::ImageViewCreateInfo & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| VULKAN_HPP_NAMESPACE::ImageView view; |
| Result result = static_cast<Result>( |
| d.vkCreateImageView( m_device, |
| reinterpret_cast<const VkImageViewCreateInfo *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), |
| reinterpret_cast<VkImageView *>( &view ) ) ); |
| return createResultValue( result, view, VULKAN_HPP_NAMESPACE_STRING "::Device::createImageView" ); |
| } |
| |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE |
| template <typename Dispatch> |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE |
| typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ImageView, Dispatch>>::type |
| Device::createImageViewUnique( const VULKAN_HPP_NAMESPACE::ImageViewCreateInfo & createInfo, |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, |
| Dispatch const & d ) const |
| { |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); |
| VULKAN_HPP_NAMESPACE::ImageView view; |
| Result result = static_cast<Result>( |
| d.vkCreateImageView( m_device, |
| reinterpret_cast<const VkImageViewCreateInfo *>( &createInfo ), |
| reinterpret_cast<const VkAllocationCallbacks *>( |
|
