| // 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 *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkImageView *>( &view ) ) ); | |
| ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d ); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::ImageView, Dispatch>( | |
| result, view, VULKAN_HPP_NAMESPACE_STRING "::Device::createImageViewUnique", deleter ); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroyImageView( VULKAN_HPP_NAMESPACE::ImageView imageView, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyImageView( | |
| m_device, static_cast<VkImageView>( imageView ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroyImageView( VULKAN_HPP_NAMESPACE::ImageView imageView, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyImageView( m_device, | |
| static_cast<VkImageView>( imageView ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::ImageView imageView, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyImageView( | |
| m_device, static_cast<VkImageView>( imageView ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::ImageView imageView, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyImageView( m_device, | |
| static_cast<VkImageView>( imageView ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::createShaderModule( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo * pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| VULKAN_HPP_NAMESPACE::ShaderModule * pShaderModule, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkCreateShaderModule( m_device, | |
| reinterpret_cast<const VkShaderModuleCreateInfo *>( pCreateInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), | |
| reinterpret_cast<VkShaderModule *>( pShaderModule ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<VULKAN_HPP_NAMESPACE::ShaderModule>::type | |
| Device::createShaderModule( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo & createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::ShaderModule shaderModule; | |
| Result result = static_cast<Result>( | |
| d.vkCreateShaderModule( m_device, | |
| reinterpret_cast<const VkShaderModuleCreateInfo *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkShaderModule *>( &shaderModule ) ) ); | |
| return createResultValue( result, shaderModule, VULKAN_HPP_NAMESPACE_STRING "::Device::createShaderModule" ); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderModule, Dispatch>>::type | |
| Device::createShaderModuleUnique( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo & createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::ShaderModule shaderModule; | |
| Result result = static_cast<Result>( | |
| d.vkCreateShaderModule( m_device, | |
| reinterpret_cast<const VkShaderModuleCreateInfo *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkShaderModule *>( &shaderModule ) ) ); | |
| ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d ); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::ShaderModule, Dispatch>( | |
| result, shaderModule, VULKAN_HPP_NAMESPACE_STRING "::Device::createShaderModuleUnique", deleter ); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroyShaderModule( VULKAN_HPP_NAMESPACE::ShaderModule shaderModule, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyShaderModule( m_device, | |
| static_cast<VkShaderModule>( shaderModule ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| Device::destroyShaderModule( VULKAN_HPP_NAMESPACE::ShaderModule shaderModule, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyShaderModule( m_device, | |
| static_cast<VkShaderModule>( shaderModule ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::ShaderModule shaderModule, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyShaderModule( m_device, | |
| static_cast<VkShaderModule>( shaderModule ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::ShaderModule shaderModule, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyShaderModule( m_device, | |
| static_cast<VkShaderModule>( shaderModule ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::createPipelineCache( const VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo * pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| VULKAN_HPP_NAMESPACE::PipelineCache * pPipelineCache, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkCreatePipelineCache( m_device, | |
| reinterpret_cast<const VkPipelineCacheCreateInfo *>( pCreateInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), | |
| reinterpret_cast<VkPipelineCache *>( pPipelineCache ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<VULKAN_HPP_NAMESPACE::PipelineCache>::type | |
| Device::createPipelineCache( const VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo & createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache; | |
| Result result = static_cast<Result>( | |
| d.vkCreatePipelineCache( m_device, | |
| reinterpret_cast<const VkPipelineCacheCreateInfo *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkPipelineCache *>( &pipelineCache ) ) ); | |
| return createResultValue( result, pipelineCache, VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineCache" ); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineCache, Dispatch>>::type | |
| Device::createPipelineCacheUnique( const VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo & createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache; | |
| Result result = static_cast<Result>( | |
| d.vkCreatePipelineCache( m_device, | |
| reinterpret_cast<const VkPipelineCacheCreateInfo *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkPipelineCache *>( &pipelineCache ) ) ); | |
| ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d ); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::PipelineCache, Dispatch>( | |
| result, pipelineCache, VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineCacheUnique", deleter ); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroyPipelineCache( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyPipelineCache( m_device, | |
| static_cast<VkPipelineCache>( pipelineCache ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| Device::destroyPipelineCache( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyPipelineCache( m_device, | |
| static_cast<VkPipelineCache>( pipelineCache ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyPipelineCache( m_device, | |
| static_cast<VkPipelineCache>( pipelineCache ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyPipelineCache( m_device, | |
| static_cast<VkPipelineCache>( pipelineCache ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::getPipelineCacheData( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| size_t * pDataSize, | |
| void * pData, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkGetPipelineCacheData( m_device, static_cast<VkPipelineCache>( pipelineCache ), pDataSize, pData ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Uint8_tAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type | |
| Device::getPipelineCacheData( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<uint8_t, Uint8_tAllocator> data; | |
| size_t dataSize; | |
| Result result; | |
| do | |
| { | |
| result = static_cast<Result>( | |
| d.vkGetPipelineCacheData( m_device, static_cast<VkPipelineCache>( pipelineCache ), &dataSize, nullptr ) ); | |
| if ( ( result == Result::eSuccess ) && dataSize ) | |
| { | |
| data.resize( dataSize ); | |
| result = static_cast<Result>( d.vkGetPipelineCacheData( m_device, | |
| static_cast<VkPipelineCache>( pipelineCache ), | |
| &dataSize, | |
| reinterpret_cast<void *>( data.data() ) ) ); | |
| VULKAN_HPP_ASSERT( dataSize <= data.size() ); | |
| } | |
| } while ( result == Result::eIncomplete ); | |
| if ( ( result == Result::eSuccess ) && ( dataSize < data.size() ) ) | |
| { | |
| data.resize( dataSize ); | |
| } | |
| return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineCacheData" ); | |
| } | |
| template <typename Uint8_tAllocator, | |
| typename Dispatch, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, uint8_t>::value, int>::type> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type | |
| Device::getPipelineCacheData( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| Uint8_tAllocator & uint8_tAllocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<uint8_t, Uint8_tAllocator> data( uint8_tAllocator ); | |
| size_t dataSize; | |
| Result result; | |
| do | |
| { | |
| result = static_cast<Result>( | |
| d.vkGetPipelineCacheData( m_device, static_cast<VkPipelineCache>( pipelineCache ), &dataSize, nullptr ) ); | |
| if ( ( result == Result::eSuccess ) && dataSize ) | |
| { | |
| data.resize( dataSize ); | |
| result = static_cast<Result>( d.vkGetPipelineCacheData( m_device, | |
| static_cast<VkPipelineCache>( pipelineCache ), | |
| &dataSize, | |
| reinterpret_cast<void *>( data.data() ) ) ); | |
| VULKAN_HPP_ASSERT( dataSize <= data.size() ); | |
| } | |
| } while ( result == Result::eIncomplete ); | |
| if ( ( result == Result::eSuccess ) && ( dataSize < data.size() ) ) | |
| { | |
| data.resize( dataSize ); | |
| } | |
| return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineCacheData" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::mergePipelineCaches( VULKAN_HPP_NAMESPACE::PipelineCache dstCache, | |
| uint32_t srcCacheCount, | |
| const VULKAN_HPP_NAMESPACE::PipelineCache * pSrcCaches, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkMergePipelineCaches( m_device, | |
| static_cast<VkPipelineCache>( dstCache ), | |
| srcCacheCount, | |
| reinterpret_cast<const VkPipelineCache *>( pSrcCaches ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| Device::mergePipelineCaches( VULKAN_HPP_NAMESPACE::PipelineCache dstCache, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::PipelineCache> const & srcCaches, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| Result result = | |
| static_cast<Result>( d.vkMergePipelineCaches( m_device, | |
| static_cast<VkPipelineCache>( dstCache ), | |
| srcCaches.size(), | |
| reinterpret_cast<const VkPipelineCache *>( srcCaches.data() ) ) ); | |
| return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::mergePipelineCaches" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::createGraphicsPipelines( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| uint32_t createInfoCount, | |
| const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo * pCreateInfos, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| VULKAN_HPP_NAMESPACE::Pipeline * pPipelines, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkCreateGraphicsPipelines( m_device, | |
| static_cast<VkPipelineCache>( pipelineCache ), | |
| createInfoCount, | |
| reinterpret_cast<const VkGraphicsPipelineCreateInfo *>( pCreateInfos ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), | |
| reinterpret_cast<VkPipeline *>( pPipelines ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename PipelineAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>> | |
| Device::createGraphicsPipelines( | |
| VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator> pipelines( createInfos.size() ); | |
| Result result = static_cast<Result>( | |
| d.vkCreateGraphicsPipelines( m_device, | |
| static_cast<VkPipelineCache>( pipelineCache ), | |
| createInfos.size(), | |
| reinterpret_cast<const VkGraphicsPipelineCreateInfo *>( createInfos.data() ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkPipeline *>( pipelines.data() ) ) ); | |
| return createResultValue( | |
| result, | |
| pipelines, | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelines", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); | |
| } | |
| template <typename PipelineAllocator, | |
| typename Dispatch, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, Pipeline>::value, int>::type> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>> | |
| Device::createGraphicsPipelines( | |
| VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| PipelineAllocator & pipelineAllocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator> pipelines( createInfos.size(), pipelineAllocator ); | |
| Result result = static_cast<Result>( | |
| d.vkCreateGraphicsPipelines( m_device, | |
| static_cast<VkPipelineCache>( pipelineCache ), | |
| createInfos.size(), | |
| reinterpret_cast<const VkGraphicsPipelineCreateInfo *>( createInfos.data() ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkPipeline *>( pipelines.data() ) ) ); | |
| return createResultValue( | |
| result, | |
| pipelines, | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelines", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<VULKAN_HPP_NAMESPACE::Pipeline> | |
| Device::createGraphicsPipeline( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo & createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::Pipeline pipeline; | |
| Result result = static_cast<Result>( | |
| d.vkCreateGraphicsPipelines( m_device, | |
| static_cast<VkPipelineCache>( pipelineCache ), | |
| 1, | |
| reinterpret_cast<const VkGraphicsPipelineCreateInfo *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkPipeline *>( &pipeline ) ) ); | |
| return createResultValue( | |
| result, | |
| pipeline, | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipeline", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template <typename Dispatch, typename PipelineAllocator> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>> | |
| Device::createGraphicsPipelinesUnique( | |
| VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator> uniquePipelines; | |
| std::vector<Pipeline> pipelines( createInfos.size() ); | |
| Result result = static_cast<Result>( | |
| d.vkCreateGraphicsPipelines( m_device, | |
| static_cast<VkPipelineCache>( pipelineCache ), | |
| createInfos.size(), | |
| reinterpret_cast<const VkGraphicsPipelineCreateInfo *>( createInfos.data() ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkPipeline *>( pipelines.data() ) ) ); | |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) || | |
| ( result == VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) ) | |
| { | |
| uniquePipelines.reserve( createInfos.size() ); | |
| ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d ); | |
| for ( size_t i = 0; i < createInfos.size(); i++ ) | |
| { | |
| uniquePipelines.push_back( UniqueHandle<Pipeline, Dispatch>( pipelines[i], deleter ) ); | |
| } | |
| } | |
| return createResultValue( | |
| result, | |
| std::move( uniquePipelines ), | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelinesUnique", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); | |
| } | |
| template < | |
| typename Dispatch, | |
| typename PipelineAllocator, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<Pipeline, Dispatch>>::value, int>::type> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>> | |
| Device::createGraphicsPipelinesUnique( | |
| VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| PipelineAllocator & pipelineAllocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator> uniquePipelines( pipelineAllocator ); | |
| std::vector<Pipeline> pipelines( createInfos.size() ); | |
| Result result = static_cast<Result>( | |
| d.vkCreateGraphicsPipelines( m_device, | |
| static_cast<VkPipelineCache>( pipelineCache ), | |
| createInfos.size(), | |
| reinterpret_cast<const VkGraphicsPipelineCreateInfo *>( createInfos.data() ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkPipeline *>( pipelines.data() ) ) ); | |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) || | |
| ( result == VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) ) | |
| { | |
| uniquePipelines.reserve( createInfos.size() ); | |
| ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d ); | |
| for ( size_t i = 0; i < createInfos.size(); i++ ) | |
| { | |
| uniquePipelines.push_back( UniqueHandle<Pipeline, Dispatch>( pipelines[i], deleter ) ); | |
| } | |
| } | |
| return createResultValue( | |
| result, | |
| std::move( uniquePipelines ), | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelinesUnique", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<UniqueHandle<Pipeline, Dispatch>> | |
| Device::createGraphicsPipelineUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo & createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| Pipeline pipeline; | |
| Result result = static_cast<Result>( | |
| d.vkCreateGraphicsPipelines( m_device, | |
| static_cast<VkPipelineCache>( pipelineCache ), | |
| 1, | |
| reinterpret_cast<const VkGraphicsPipelineCreateInfo *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkPipeline *>( &pipeline ) ) ); | |
| ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d ); | |
| return createResultValue<Pipeline, Dispatch>( | |
| result, | |
| pipeline, | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelineUnique", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT }, | |
| deleter ); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::createComputePipelines( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| uint32_t createInfoCount, | |
| const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo * pCreateInfos, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| VULKAN_HPP_NAMESPACE::Pipeline * pPipelines, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkCreateComputePipelines( m_device, | |
| static_cast<VkPipelineCache>( pipelineCache ), | |
| createInfoCount, | |
| reinterpret_cast<const VkComputePipelineCreateInfo *>( pCreateInfos ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), | |
| reinterpret_cast<VkPipeline *>( pPipelines ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename PipelineAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>> | |
| Device::createComputePipelines( | |
| VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator> pipelines( createInfos.size() ); | |
| Result result = static_cast<Result>( | |
| d.vkCreateComputePipelines( m_device, | |
| static_cast<VkPipelineCache>( pipelineCache ), | |
| createInfos.size(), | |
| reinterpret_cast<const VkComputePipelineCreateInfo *>( createInfos.data() ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkPipeline *>( pipelines.data() ) ) ); | |
| return createResultValue( | |
| result, | |
| pipelines, | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelines", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); | |
| } | |
| template <typename PipelineAllocator, | |
| typename Dispatch, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, Pipeline>::value, int>::type> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>> | |
| Device::createComputePipelines( | |
| VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| PipelineAllocator & pipelineAllocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator> pipelines( createInfos.size(), pipelineAllocator ); | |
| Result result = static_cast<Result>( | |
| d.vkCreateComputePipelines( m_device, | |
| static_cast<VkPipelineCache>( pipelineCache ), | |
| createInfos.size(), | |
| reinterpret_cast<const VkComputePipelineCreateInfo *>( createInfos.data() ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkPipeline *>( pipelines.data() ) ) ); | |
| return createResultValue( | |
| result, | |
| pipelines, | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelines", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<VULKAN_HPP_NAMESPACE::Pipeline> | |
| Device::createComputePipeline( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo & createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::Pipeline pipeline; | |
| Result result = static_cast<Result>( | |
| d.vkCreateComputePipelines( m_device, | |
| static_cast<VkPipelineCache>( pipelineCache ), | |
| 1, | |
| reinterpret_cast<const VkComputePipelineCreateInfo *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkPipeline *>( &pipeline ) ) ); | |
| return createResultValue( | |
| result, | |
| pipeline, | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipeline", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template <typename Dispatch, typename PipelineAllocator> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>> | |
| Device::createComputePipelinesUnique( | |
| VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator> uniquePipelines; | |
| std::vector<Pipeline> pipelines( createInfos.size() ); | |
| Result result = static_cast<Result>( | |
| d.vkCreateComputePipelines( m_device, | |
| static_cast<VkPipelineCache>( pipelineCache ), | |
| createInfos.size(), | |
| reinterpret_cast<const VkComputePipelineCreateInfo *>( createInfos.data() ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkPipeline *>( pipelines.data() ) ) ); | |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) || | |
| ( result == VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) ) | |
| { | |
| uniquePipelines.reserve( createInfos.size() ); | |
| ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d ); | |
| for ( size_t i = 0; i < createInfos.size(); i++ ) | |
| { | |
| uniquePipelines.push_back( UniqueHandle<Pipeline, Dispatch>( pipelines[i], deleter ) ); | |
| } | |
| } | |
| return createResultValue( | |
| result, | |
| std::move( uniquePipelines ), | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelinesUnique", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); | |
| } | |
| template < | |
| typename Dispatch, | |
| typename PipelineAllocator, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<Pipeline, Dispatch>>::value, int>::type> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>> | |
| Device::createComputePipelinesUnique( | |
| VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| PipelineAllocator & pipelineAllocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator> uniquePipelines( pipelineAllocator ); | |
| std::vector<Pipeline> pipelines( createInfos.size() ); | |
| Result result = static_cast<Result>( | |
| d.vkCreateComputePipelines( m_device, | |
| static_cast<VkPipelineCache>( pipelineCache ), | |
| createInfos.size(), | |
| reinterpret_cast<const VkComputePipelineCreateInfo *>( createInfos.data() ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkPipeline *>( pipelines.data() ) ) ); | |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) || | |
| ( result == VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) ) | |
| { | |
| uniquePipelines.reserve( createInfos.size() ); | |
| ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d ); | |
| for ( size_t i = 0; i < createInfos.size(); i++ ) | |
| { | |
| uniquePipelines.push_back( UniqueHandle<Pipeline, Dispatch>( pipelines[i], deleter ) ); | |
| } | |
| } | |
| return createResultValue( | |
| result, | |
| std::move( uniquePipelines ), | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelinesUnique", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<UniqueHandle<Pipeline, Dispatch>> | |
| Device::createComputePipelineUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo & createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| Pipeline pipeline; | |
| Result result = static_cast<Result>( | |
| d.vkCreateComputePipelines( m_device, | |
| static_cast<VkPipelineCache>( pipelineCache ), | |
| 1, | |
| reinterpret_cast<const VkComputePipelineCreateInfo *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkPipeline *>( &pipeline ) ) ); | |
| ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d ); | |
| return createResultValue<Pipeline, Dispatch>( | |
| result, | |
| pipeline, | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelineUnique", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT }, | |
| deleter ); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroyPipeline( VULKAN_HPP_NAMESPACE::Pipeline pipeline, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyPipeline( | |
| m_device, static_cast<VkPipeline>( pipeline ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroyPipeline( VULKAN_HPP_NAMESPACE::Pipeline pipeline, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyPipeline( m_device, | |
| static_cast<VkPipeline>( pipeline ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Pipeline pipeline, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyPipeline( | |
| m_device, static_cast<VkPipeline>( pipeline ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Pipeline pipeline, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyPipeline( m_device, | |
| static_cast<VkPipeline>( pipeline ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::createPipelineLayout( const VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo * pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| VULKAN_HPP_NAMESPACE::PipelineLayout * pPipelineLayout, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkCreatePipelineLayout( m_device, | |
| reinterpret_cast<const VkPipelineLayoutCreateInfo *>( pCreateInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), | |
| reinterpret_cast<VkPipelineLayout *>( pPipelineLayout ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<VULKAN_HPP_NAMESPACE::PipelineLayout>::type | |
| Device::createPipelineLayout( const VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo & createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout; | |
| Result result = static_cast<Result>( | |
| d.vkCreatePipelineLayout( m_device, | |
| reinterpret_cast<const VkPipelineLayoutCreateInfo *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkPipelineLayout *>( &pipelineLayout ) ) ); | |
| return createResultValue( result, pipelineLayout, VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineLayout" ); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineLayout, Dispatch>>::type | |
| Device::createPipelineLayoutUnique( const VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo & createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout; | |
| Result result = static_cast<Result>( | |
| d.vkCreatePipelineLayout( m_device, | |
| reinterpret_cast<const VkPipelineLayoutCreateInfo *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkPipelineLayout *>( &pipelineLayout ) ) ); | |
| ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d ); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::PipelineLayout, Dispatch>( | |
| result, pipelineLayout, VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineLayoutUnique", deleter ); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroyPipelineLayout( VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyPipelineLayout( m_device, | |
| static_cast<VkPipelineLayout>( pipelineLayout ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| Device::destroyPipelineLayout( VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyPipelineLayout( m_device, | |
| static_cast<VkPipelineLayout>( pipelineLayout ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyPipelineLayout( m_device, | |
| static_cast<VkPipelineLayout>( pipelineLayout ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyPipelineLayout( m_device, | |
| static_cast<VkPipelineLayout>( pipelineLayout ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::createSampler( const VULKAN_HPP_NAMESPACE::SamplerCreateInfo * pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| VULKAN_HPP_NAMESPACE::Sampler * pSampler, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkCreateSampler( m_device, | |
| reinterpret_cast<const VkSamplerCreateInfo *>( pCreateInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), | |
| reinterpret_cast<VkSampler *>( pSampler ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<VULKAN_HPP_NAMESPACE::Sampler>::type | |
| Device::createSampler( const VULKAN_HPP_NAMESPACE::SamplerCreateInfo & createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::Sampler sampler; | |
| Result result = static_cast<Result>( | |
| d.vkCreateSampler( m_device, | |
| reinterpret_cast<const VkSamplerCreateInfo *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkSampler *>( &sampler ) ) ); | |
| return createResultValue( result, sampler, VULKAN_HPP_NAMESPACE_STRING "::Device::createSampler" ); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Sampler, Dispatch>>::type | |
| Device::createSamplerUnique( const VULKAN_HPP_NAMESPACE::SamplerCreateInfo & createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::Sampler sampler; | |
| Result result = static_cast<Result>( | |
| d.vkCreateSampler( m_device, | |
| reinterpret_cast<const VkSamplerCreateInfo *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkSampler *>( &sampler ) ) ); | |
| ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d ); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::Sampler, Dispatch>( | |
| result, sampler, VULKAN_HPP_NAMESPACE_STRING "::Device::createSamplerUnique", deleter ); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroySampler( VULKAN_HPP_NAMESPACE::Sampler sampler, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroySampler( | |
| m_device, static_cast<VkSampler>( sampler ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroySampler( VULKAN_HPP_NAMESPACE::Sampler sampler, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroySampler( m_device, | |
| static_cast<VkSampler>( sampler ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Sampler sampler, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroySampler( | |
| m_device, static_cast<VkSampler>( sampler ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Sampler sampler, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroySampler( m_device, | |
| static_cast<VkSampler>( sampler ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::createDescriptorSetLayout( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo * pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| VULKAN_HPP_NAMESPACE::DescriptorSetLayout * pSetLayout, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkCreateDescriptorSetLayout( m_device, | |
| reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( pCreateInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), | |
| reinterpret_cast<VkDescriptorSetLayout *>( pSetLayout ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<VULKAN_HPP_NAMESPACE::DescriptorSetLayout>::type | |
| Device::createDescriptorSetLayout( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::DescriptorSetLayout setLayout; | |
| Result result = static_cast<Result>( | |
| d.vkCreateDescriptorSetLayout( m_device, | |
| reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkDescriptorSetLayout *>( &setLayout ) ) ); | |
| return createResultValue( result, setLayout, VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorSetLayout" ); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSetLayout, Dispatch>>::type | |
| Device::createDescriptorSetLayoutUnique( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::DescriptorSetLayout setLayout; | |
| Result result = static_cast<Result>( | |
| d.vkCreateDescriptorSetLayout( m_device, | |
| reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkDescriptorSetLayout *>( &setLayout ) ) ); | |
| ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d ); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::DescriptorSetLayout, Dispatch>( | |
| result, setLayout, VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorSetLayoutUnique", deleter ); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| Device::destroyDescriptorSetLayout( VULKAN_HPP_NAMESPACE::DescriptorSetLayout descriptorSetLayout, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyDescriptorSetLayout( m_device, | |
| static_cast<VkDescriptorSetLayout>( descriptorSetLayout ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| Device::destroyDescriptorSetLayout( VULKAN_HPP_NAMESPACE::DescriptorSetLayout descriptorSetLayout, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyDescriptorSetLayout( m_device, | |
| static_cast<VkDescriptorSetLayout>( descriptorSetLayout ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::DescriptorSetLayout descriptorSetLayout, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyDescriptorSetLayout( m_device, | |
| static_cast<VkDescriptorSetLayout>( descriptorSetLayout ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::DescriptorSetLayout descriptorSetLayout, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyDescriptorSetLayout( m_device, | |
| static_cast<VkDescriptorSetLayout>( descriptorSetLayout ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::createDescriptorPool( const VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo * pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| VULKAN_HPP_NAMESPACE::DescriptorPool * pDescriptorPool, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkCreateDescriptorPool( m_device, | |
| reinterpret_cast<const VkDescriptorPoolCreateInfo *>( pCreateInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), | |
| reinterpret_cast<VkDescriptorPool *>( pDescriptorPool ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<VULKAN_HPP_NAMESPACE::DescriptorPool>::type | |
| Device::createDescriptorPool( const VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo & createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool; | |
| Result result = static_cast<Result>( | |
| d.vkCreateDescriptorPool( m_device, | |
| reinterpret_cast<const VkDescriptorPoolCreateInfo *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkDescriptorPool *>( &descriptorPool ) ) ); | |
| return createResultValue( result, descriptorPool, VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorPool" ); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorPool, Dispatch>>::type | |
| Device::createDescriptorPoolUnique( const VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo & createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool; | |
| Result result = static_cast<Result>( | |
| d.vkCreateDescriptorPool( m_device, | |
| reinterpret_cast<const VkDescriptorPoolCreateInfo *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkDescriptorPool *>( &descriptorPool ) ) ); | |
| ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d ); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::DescriptorPool, Dispatch>( | |
| result, descriptorPool, VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorPoolUnique", deleter ); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroyDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyDescriptorPool( m_device, | |
| static_cast<VkDescriptorPool>( descriptorPool ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| Device::destroyDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyDescriptorPool( m_device, | |
| static_cast<VkDescriptorPool>( descriptorPool ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyDescriptorPool( m_device, | |
| static_cast<VkDescriptorPool>( descriptorPool ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyDescriptorPool( m_device, | |
| static_cast<VkDescriptorPool>( descriptorPool ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE Result Device::resetDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, | |
| VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlags flags, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkResetDescriptorPool( | |
| m_device, static_cast<VkDescriptorPool>( descriptorPool ), static_cast<VkDescriptorPoolResetFlags>( flags ) ) ); | |
| } | |
| #else | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| Device::resetDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, | |
| VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlags flags, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| Result result = static_cast<Result>( d.vkResetDescriptorPool( | |
| m_device, static_cast<VkDescriptorPool>( descriptorPool ), static_cast<VkDescriptorPoolResetFlags>( flags ) ) ); | |
| return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::resetDescriptorPool" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::allocateDescriptorSets( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo * pAllocateInfo, | |
| VULKAN_HPP_NAMESPACE::DescriptorSet * pDescriptorSets, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkAllocateDescriptorSets( m_device, | |
| reinterpret_cast<const VkDescriptorSetAllocateInfo *>( pAllocateInfo ), | |
| reinterpret_cast<VkDescriptorSet *>( pDescriptorSets ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename DescriptorSetAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DescriptorSet, DescriptorSetAllocator>>::type | |
| Device::allocateDescriptorSets( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo & allocateInfo, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<VULKAN_HPP_NAMESPACE::DescriptorSet, DescriptorSetAllocator> descriptorSets( | |
| allocateInfo.descriptorSetCount ); | |
| Result result = static_cast<Result>( | |
| d.vkAllocateDescriptorSets( m_device, | |
| reinterpret_cast<const VkDescriptorSetAllocateInfo *>( &allocateInfo ), | |
| reinterpret_cast<VkDescriptorSet *>( descriptorSets.data() ) ) ); | |
| return createResultValue( result, descriptorSets, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSets" ); | |
| } | |
| template <typename DescriptorSetAllocator, | |
| typename Dispatch, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, DescriptorSet>::value, int>::type> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DescriptorSet, DescriptorSetAllocator>>::type | |
| Device::allocateDescriptorSets( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo & allocateInfo, | |
| DescriptorSetAllocator & descriptorSetAllocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<VULKAN_HPP_NAMESPACE::DescriptorSet, DescriptorSetAllocator> descriptorSets( | |
| allocateInfo.descriptorSetCount, descriptorSetAllocator ); | |
| Result result = static_cast<Result>( | |
| d.vkAllocateDescriptorSets( m_device, | |
| reinterpret_cast<const VkDescriptorSetAllocateInfo *>( &allocateInfo ), | |
| reinterpret_cast<VkDescriptorSet *>( descriptorSets.data() ) ) ); | |
| return createResultValue( result, descriptorSets, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSets" ); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template <typename Dispatch, typename DescriptorSetAllocator> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<std::vector<UniqueHandle<DescriptorSet, Dispatch>, DescriptorSetAllocator>>::type | |
| Device::allocateDescriptorSetsUnique( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo & allocateInfo, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<UniqueHandle<DescriptorSet, Dispatch>, DescriptorSetAllocator> uniqueDescriptorSets; | |
| std::vector<DescriptorSet> descriptorSets( allocateInfo.descriptorSetCount ); | |
| Result result = static_cast<Result>( | |
| d.vkAllocateDescriptorSets( m_device, | |
| reinterpret_cast<const VkDescriptorSetAllocateInfo *>( &allocateInfo ), | |
| reinterpret_cast<VkDescriptorSet *>( descriptorSets.data() ) ) ); | |
| if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) | |
| { | |
| uniqueDescriptorSets.reserve( allocateInfo.descriptorSetCount ); | |
| PoolFree<Device, DescriptorPool, Dispatch> deleter( *this, allocateInfo.descriptorPool, d ); | |
| for ( size_t i = 0; i < allocateInfo.descriptorSetCount; i++ ) | |
| { | |
| uniqueDescriptorSets.push_back( UniqueHandle<DescriptorSet, Dispatch>( descriptorSets[i], deleter ) ); | |
| } | |
| } | |
| return createResultValue( | |
| result, std::move( uniqueDescriptorSets ), VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSetsUnique" ); | |
| } | |
| template <typename Dispatch, | |
| typename DescriptorSetAllocator, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<DescriptorSet, Dispatch>>::value, | |
| int>::type> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<std::vector<UniqueHandle<DescriptorSet, Dispatch>, DescriptorSetAllocator>>::type | |
| Device::allocateDescriptorSetsUnique( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo & allocateInfo, | |
| DescriptorSetAllocator & descriptorSetAllocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<UniqueHandle<DescriptorSet, Dispatch>, DescriptorSetAllocator> uniqueDescriptorSets( | |
| descriptorSetAllocator ); | |
| std::vector<DescriptorSet> descriptorSets( allocateInfo.descriptorSetCount ); | |
| Result result = static_cast<Result>( | |
| d.vkAllocateDescriptorSets( m_device, | |
| reinterpret_cast<const VkDescriptorSetAllocateInfo *>( &allocateInfo ), | |
| reinterpret_cast<VkDescriptorSet *>( descriptorSets.data() ) ) ); | |
| if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) | |
| { | |
| uniqueDescriptorSets.reserve( allocateInfo.descriptorSetCount ); | |
| PoolFree<Device, DescriptorPool, Dispatch> deleter( *this, allocateInfo.descriptorPool, d ); | |
| for ( size_t i = 0; i < allocateInfo.descriptorSetCount; i++ ) | |
| { | |
| uniqueDescriptorSets.push_back( UniqueHandle<DescriptorSet, Dispatch>( descriptorSets[i], deleter ) ); | |
| } | |
| } | |
| return createResultValue( | |
| result, std::move( uniqueDescriptorSets ), VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSetsUnique" ); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE Result Device::freeDescriptorSets( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, | |
| uint32_t descriptorSetCount, | |
| const VULKAN_HPP_NAMESPACE::DescriptorSet * pDescriptorSets, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkFreeDescriptorSets( m_device, | |
| static_cast<VkDescriptorPool>( descriptorPool ), | |
| descriptorSetCount, | |
| reinterpret_cast<const VkDescriptorSet *>( pDescriptorSets ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| Device::freeDescriptorSets( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const & descriptorSets, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| Result result = static_cast<Result>( | |
| d.vkFreeDescriptorSets( m_device, | |
| static_cast<VkDescriptorPool>( descriptorPool ), | |
| descriptorSets.size(), | |
| reinterpret_cast<const VkDescriptorSet *>( descriptorSets.data() ) ) ); | |
| return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::freeDescriptorSets" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE Result Device::free( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, | |
| uint32_t descriptorSetCount, | |
| const VULKAN_HPP_NAMESPACE::DescriptorSet * pDescriptorSets, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkFreeDescriptorSets( m_device, | |
| static_cast<VkDescriptorPool>( descriptorPool ), | |
| descriptorSetCount, | |
| reinterpret_cast<const VkDescriptorSet *>( pDescriptorSets ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| Device::free( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const & descriptorSets, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| Result result = static_cast<Result>( | |
| d.vkFreeDescriptorSets( m_device, | |
| static_cast<VkDescriptorPool>( descriptorPool ), | |
| descriptorSets.size(), | |
| reinterpret_cast<const VkDescriptorSet *>( descriptorSets.data() ) ) ); | |
| return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::free" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| Device::updateDescriptorSets( uint32_t descriptorWriteCount, | |
| const VULKAN_HPP_NAMESPACE::WriteDescriptorSet * pDescriptorWrites, | |
| uint32_t descriptorCopyCount, | |
| const VULKAN_HPP_NAMESPACE::CopyDescriptorSet * pDescriptorCopies, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkUpdateDescriptorSets( m_device, | |
| descriptorWriteCount, | |
| reinterpret_cast<const VkWriteDescriptorSet *>( pDescriptorWrites ), | |
| descriptorCopyCount, | |
| reinterpret_cast<const VkCopyDescriptorSet *>( pDescriptorCopies ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| Device::updateDescriptorSets( ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::CopyDescriptorSet> const & descriptorCopies, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkUpdateDescriptorSets( m_device, | |
| descriptorWrites.size(), | |
| reinterpret_cast<const VkWriteDescriptorSet *>( descriptorWrites.data() ), | |
| descriptorCopies.size(), | |
| reinterpret_cast<const VkCopyDescriptorSet *>( descriptorCopies.data() ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::createFramebuffer( const VULKAN_HPP_NAMESPACE::FramebufferCreateInfo * pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| VULKAN_HPP_NAMESPACE::Framebuffer * pFramebuffer, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkCreateFramebuffer( m_device, | |
| reinterpret_cast<const VkFramebufferCreateInfo *>( pCreateInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), | |
| reinterpret_cast<VkFramebuffer *>( pFramebuffer ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<VULKAN_HPP_NAMESPACE::Framebuffer>::type | |
| Device::createFramebuffer( const VULKAN_HPP_NAMESPACE::FramebufferCreateInfo & createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::Framebuffer framebuffer; | |
| Result result = static_cast<Result>( | |
| d.vkCreateFramebuffer( m_device, | |
| reinterpret_cast<const VkFramebufferCreateInfo *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkFramebuffer *>( &framebuffer ) ) ); | |
| return createResultValue( result, framebuffer, VULKAN_HPP_NAMESPACE_STRING "::Device::createFramebuffer" ); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Framebuffer, Dispatch>>::type | |
| Device::createFramebufferUnique( const VULKAN_HPP_NAMESPACE::FramebufferCreateInfo & createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::Framebuffer framebuffer; | |
| Result result = static_cast<Result>( | |
| d.vkCreateFramebuffer( m_device, | |
| reinterpret_cast<const VkFramebufferCreateInfo *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkFramebuffer *>( &framebuffer ) ) ); | |
| ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d ); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::Framebuffer, Dispatch>( | |
| result, framebuffer, VULKAN_HPP_NAMESPACE_STRING "::Device::createFramebufferUnique", deleter ); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroyFramebuffer( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyFramebuffer( m_device, | |
| static_cast<VkFramebuffer>( framebuffer ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| Device::destroyFramebuffer( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyFramebuffer( m_device, | |
| static_cast<VkFramebuffer>( framebuffer ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyFramebuffer( m_device, | |
| static_cast<VkFramebuffer>( framebuffer ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyFramebuffer( m_device, | |
| static_cast<VkFramebuffer>( framebuffer ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::createRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo * pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| VULKAN_HPP_NAMESPACE::RenderPass * pRenderPass, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkCreateRenderPass( m_device, | |
| reinterpret_cast<const VkRenderPassCreateInfo *>( pCreateInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), | |
| reinterpret_cast<VkRenderPass *>( pRenderPass ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<VULKAN_HPP_NAMESPACE::RenderPass>::type | |
| Device::createRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo & createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::RenderPass renderPass; | |
| Result result = static_cast<Result>( | |
| d.vkCreateRenderPass( m_device, | |
| reinterpret_cast<const VkRenderPassCreateInfo *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkRenderPass *>( &renderPass ) ) ); | |
| return createResultValue( result, renderPass, VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPass" ); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>>::type | |
| Device::createRenderPassUnique( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo & createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::RenderPass renderPass; | |
| Result result = static_cast<Result>( | |
| d.vkCreateRenderPass( m_device, | |
| reinterpret_cast<const VkRenderPassCreateInfo *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkRenderPass *>( &renderPass ) ) ); | |
| ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d ); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>( | |
| result, renderPass, VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPassUnique", deleter ); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroyRenderPass( VULKAN_HPP_NAMESPACE::RenderPass renderPass, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyRenderPass( m_device, | |
| static_cast<VkRenderPass>( renderPass ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroyRenderPass( VULKAN_HPP_NAMESPACE::RenderPass renderPass, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyRenderPass( m_device, | |
| static_cast<VkRenderPass>( renderPass ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::RenderPass renderPass, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyRenderPass( m_device, | |
| static_cast<VkRenderPass>( renderPass ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::RenderPass renderPass, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyRenderPass( m_device, | |
| static_cast<VkRenderPass>( renderPass ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::getRenderAreaGranularity( VULKAN_HPP_NAMESPACE::RenderPass renderPass, | |
| VULKAN_HPP_NAMESPACE::Extent2D * pGranularity, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkGetRenderAreaGranularity( | |
| m_device, static_cast<VkRenderPass>( renderPass ), reinterpret_cast<VkExtent2D *>( pGranularity ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Extent2D | |
| Device::getRenderAreaGranularity( VULKAN_HPP_NAMESPACE::RenderPass renderPass, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::Extent2D granularity; | |
| d.vkGetRenderAreaGranularity( | |
| m_device, static_cast<VkRenderPass>( renderPass ), reinterpret_cast<VkExtent2D *>( &granularity ) ); | |
| return granularity; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::createCommandPool( const VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo * pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| VULKAN_HPP_NAMESPACE::CommandPool * pCommandPool, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkCreateCommandPool( m_device, | |
| reinterpret_cast<const VkCommandPoolCreateInfo *>( pCreateInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), | |
| reinterpret_cast<VkCommandPool *>( pCommandPool ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<VULKAN_HPP_NAMESPACE::CommandPool>::type | |
| Device::createCommandPool( const VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo & createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::CommandPool commandPool; | |
| Result result = static_cast<Result>( | |
| d.vkCreateCommandPool( m_device, | |
| reinterpret_cast<const VkCommandPoolCreateInfo *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkCommandPool *>( &commandPool ) ) ); | |
| return createResultValue( result, commandPool, VULKAN_HPP_NAMESPACE_STRING "::Device::createCommandPool" ); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandPool, Dispatch>>::type | |
| Device::createCommandPoolUnique( const VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo & createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::CommandPool commandPool; | |
| Result result = static_cast<Result>( | |
| d.vkCreateCommandPool( m_device, | |
| reinterpret_cast<const VkCommandPoolCreateInfo *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkCommandPool *>( &commandPool ) ) ); | |
| ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d ); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::CommandPool, Dispatch>( | |
| result, commandPool, VULKAN_HPP_NAMESPACE_STRING "::Device::createCommandPoolUnique", deleter ); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroyCommandPool( VULKAN_HPP_NAMESPACE::CommandPool commandPool, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyCommandPool( m_device, | |
| static_cast<VkCommandPool>( commandPool ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| Device::destroyCommandPool( VULKAN_HPP_NAMESPACE::CommandPool commandPool, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyCommandPool( m_device, | |
| static_cast<VkCommandPool>( commandPool ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::CommandPool commandPool, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyCommandPool( m_device, | |
| static_cast<VkCommandPool>( commandPool ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::CommandPool commandPool, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyCommandPool( m_device, | |
| static_cast<VkCommandPool>( commandPool ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::resetCommandPool( VULKAN_HPP_NAMESPACE::CommandPool commandPool, | |
| VULKAN_HPP_NAMESPACE::CommandPoolResetFlags flags, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkResetCommandPool( | |
| m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolResetFlags>( flags ) ) ); | |
| } | |
| #else | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| Device::resetCommandPool( VULKAN_HPP_NAMESPACE::CommandPool commandPool, | |
| VULKAN_HPP_NAMESPACE::CommandPoolResetFlags flags, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| Result result = static_cast<Result>( d.vkResetCommandPool( | |
| m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolResetFlags>( flags ) ) ); | |
| return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::resetCommandPool" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::allocateCommandBuffers( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo * pAllocateInfo, | |
| VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkAllocateCommandBuffers( m_device, | |
| reinterpret_cast<const VkCommandBufferAllocateInfo *>( pAllocateInfo ), | |
| reinterpret_cast<VkCommandBuffer *>( pCommandBuffers ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename CommandBufferAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CommandBuffer, CommandBufferAllocator>>::type | |
| Device::allocateCommandBuffers( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo & allocateInfo, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<VULKAN_HPP_NAMESPACE::CommandBuffer, CommandBufferAllocator> commandBuffers( | |
| allocateInfo.commandBufferCount ); | |
| Result result = static_cast<Result>( | |
| d.vkAllocateCommandBuffers( m_device, | |
| reinterpret_cast<const VkCommandBufferAllocateInfo *>( &allocateInfo ), | |
| reinterpret_cast<VkCommandBuffer *>( commandBuffers.data() ) ) ); | |
| return createResultValue( result, commandBuffers, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffers" ); | |
| } | |
| template <typename CommandBufferAllocator, | |
| typename Dispatch, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, CommandBuffer>::value, int>::type> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CommandBuffer, CommandBufferAllocator>>::type | |
| Device::allocateCommandBuffers( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo & allocateInfo, | |
| CommandBufferAllocator & commandBufferAllocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<VULKAN_HPP_NAMESPACE::CommandBuffer, CommandBufferAllocator> commandBuffers( | |
| allocateInfo.commandBufferCount, commandBufferAllocator ); | |
| Result result = static_cast<Result>( | |
| d.vkAllocateCommandBuffers( m_device, | |
| reinterpret_cast<const VkCommandBufferAllocateInfo *>( &allocateInfo ), | |
| reinterpret_cast<VkCommandBuffer *>( commandBuffers.data() ) ) ); | |
| return createResultValue( result, commandBuffers, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffers" ); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template <typename Dispatch, typename CommandBufferAllocator> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<std::vector<UniqueHandle<CommandBuffer, Dispatch>, CommandBufferAllocator>>::type | |
| Device::allocateCommandBuffersUnique( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo & allocateInfo, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<UniqueHandle<CommandBuffer, Dispatch>, CommandBufferAllocator> uniqueCommandBuffers; | |
| std::vector<CommandBuffer> commandBuffers( allocateInfo.commandBufferCount ); | |
| Result result = static_cast<Result>( | |
| d.vkAllocateCommandBuffers( m_device, | |
| reinterpret_cast<const VkCommandBufferAllocateInfo *>( &allocateInfo ), | |
| reinterpret_cast<VkCommandBuffer *>( commandBuffers.data() ) ) ); | |
| if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) | |
| { | |
| uniqueCommandBuffers.reserve( allocateInfo.commandBufferCount ); | |
| PoolFree<Device, CommandPool, Dispatch> deleter( *this, allocateInfo.commandPool, d ); | |
| for ( size_t i = 0; i < allocateInfo.commandBufferCount; i++ ) | |
| { | |
| uniqueCommandBuffers.push_back( UniqueHandle<CommandBuffer, Dispatch>( commandBuffers[i], deleter ) ); | |
| } | |
| } | |
| return createResultValue( | |
| result, std::move( uniqueCommandBuffers ), VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffersUnique" ); | |
| } | |
| template <typename Dispatch, | |
| typename CommandBufferAllocator, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<CommandBuffer, Dispatch>>::value, | |
| int>::type> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<std::vector<UniqueHandle<CommandBuffer, Dispatch>, CommandBufferAllocator>>::type | |
| Device::allocateCommandBuffersUnique( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo & allocateInfo, | |
| CommandBufferAllocator & commandBufferAllocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<UniqueHandle<CommandBuffer, Dispatch>, CommandBufferAllocator> uniqueCommandBuffers( | |
| commandBufferAllocator ); | |
| std::vector<CommandBuffer> commandBuffers( allocateInfo.commandBufferCount ); | |
| Result result = static_cast<Result>( | |
| d.vkAllocateCommandBuffers( m_device, | |
| reinterpret_cast<const VkCommandBufferAllocateInfo *>( &allocateInfo ), | |
| reinterpret_cast<VkCommandBuffer *>( commandBuffers.data() ) ) ); | |
| if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) | |
| { | |
| uniqueCommandBuffers.reserve( allocateInfo.commandBufferCount ); | |
| PoolFree<Device, CommandPool, Dispatch> deleter( *this, allocateInfo.commandPool, d ); | |
| for ( size_t i = 0; i < allocateInfo.commandBufferCount; i++ ) | |
| { | |
| uniqueCommandBuffers.push_back( UniqueHandle<CommandBuffer, Dispatch>( commandBuffers[i], deleter ) ); | |
| } | |
| } | |
| return createResultValue( | |
| result, std::move( uniqueCommandBuffers ), VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffersUnique" ); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::freeCommandBuffers( VULKAN_HPP_NAMESPACE::CommandPool commandPool, | |
| uint32_t commandBufferCount, | |
| const VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkFreeCommandBuffers( m_device, | |
| static_cast<VkCommandPool>( commandPool ), | |
| commandBufferCount, | |
| reinterpret_cast<const VkCommandBuffer *>( pCommandBuffers ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| Device::freeCommandBuffers( VULKAN_HPP_NAMESPACE::CommandPool commandPool, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkFreeCommandBuffers( m_device, | |
| static_cast<VkCommandPool>( commandPool ), | |
| commandBuffers.size(), | |
| reinterpret_cast<const VkCommandBuffer *>( commandBuffers.data() ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::free( VULKAN_HPP_NAMESPACE::CommandPool commandPool, | |
| uint32_t commandBufferCount, | |
| const VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkFreeCommandBuffers( m_device, | |
| static_cast<VkCommandPool>( commandPool ), | |
| commandBufferCount, | |
| reinterpret_cast<const VkCommandBuffer *>( pCommandBuffers ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::free( VULKAN_HPP_NAMESPACE::CommandPool commandPool, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkFreeCommandBuffers( m_device, | |
| static_cast<VkCommandPool>( commandPool ), | |
| commandBuffers.size(), | |
| reinterpret_cast<const VkCommandBuffer *>( commandBuffers.data() ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result CommandBuffer::begin( | |
| const VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo * pBeginInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkBeginCommandBuffer( m_commandBuffer, reinterpret_cast<const VkCommandBufferBeginInfo *>( pBeginInfo ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| CommandBuffer::begin( const VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo & beginInfo, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| Result result = static_cast<Result>( | |
| d.vkBeginCommandBuffer( m_commandBuffer, reinterpret_cast<const VkCommandBufferBeginInfo *>( &beginInfo ) ) ); | |
| return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::begin" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result CommandBuffer::end( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkEndCommandBuffer( m_commandBuffer ) ); | |
| } | |
| #else | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| CommandBuffer::end( Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| Result result = static_cast<Result>( d.vkEndCommandBuffer( m_commandBuffer ) ); | |
| return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::end" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result CommandBuffer::reset( | |
| VULKAN_HPP_NAMESPACE::CommandBufferResetFlags flags, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkResetCommandBuffer( m_commandBuffer, static_cast<VkCommandBufferResetFlags>( flags ) ) ); | |
| } | |
| #else | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| CommandBuffer::reset( VULKAN_HPP_NAMESPACE::CommandBufferResetFlags flags, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| Result result = | |
| static_cast<Result>( d.vkResetCommandBuffer( m_commandBuffer, static_cast<VkCommandBufferResetFlags>( flags ) ) ); | |
| return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::reset" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::bindPipeline( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, | |
| VULKAN_HPP_NAMESPACE::Pipeline pipeline, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdBindPipeline( | |
| m_commandBuffer, static_cast<VkPipelineBindPoint>( pipelineBindPoint ), static_cast<VkPipeline>( pipeline ) ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setViewport( uint32_t firstViewport, | |
| uint32_t viewportCount, | |
| const VULKAN_HPP_NAMESPACE::Viewport * pViewports, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdSetViewport( | |
| m_commandBuffer, firstViewport, viewportCount, reinterpret_cast<const VkViewport *>( pViewports ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setViewport( uint32_t firstViewport, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdSetViewport( | |
| m_commandBuffer, firstViewport, viewports.size(), reinterpret_cast<const VkViewport *>( viewports.data() ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setScissor( uint32_t firstScissor, | |
| uint32_t scissorCount, | |
| const VULKAN_HPP_NAMESPACE::Rect2D * pScissors, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdSetScissor( m_commandBuffer, firstScissor, scissorCount, reinterpret_cast<const VkRect2D *>( pScissors ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setScissor( uint32_t firstScissor, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdSetScissor( | |
| m_commandBuffer, firstScissor, scissors.size(), reinterpret_cast<const VkRect2D *>( scissors.data() ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setLineWidth( float lineWidth, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdSetLineWidth( m_commandBuffer, lineWidth ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setDepthBias( float depthBiasConstantFactor, | |
| float depthBiasClamp, | |
| float depthBiasSlopeFactor, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdSetDepthBias( m_commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setBlendConstants( const float blendConstants[4], | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdSetBlendConstants( m_commandBuffer, blendConstants ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setDepthBounds( float minDepthBounds, | |
| float maxDepthBounds, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdSetDepthBounds( m_commandBuffer, minDepthBounds, maxDepthBounds ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setStencilCompareMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, | |
| uint32_t compareMask, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdSetStencilCompareMask( m_commandBuffer, static_cast<VkStencilFaceFlags>( faceMask ), compareMask ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setStencilWriteMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, | |
| uint32_t writeMask, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdSetStencilWriteMask( m_commandBuffer, static_cast<VkStencilFaceFlags>( faceMask ), writeMask ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setStencilReference( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, | |
| uint32_t reference, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdSetStencilReference( m_commandBuffer, static_cast<VkStencilFaceFlags>( faceMask ), reference ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorSets( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, | |
| VULKAN_HPP_NAMESPACE::PipelineLayout layout, | |
| uint32_t firstSet, | |
| uint32_t descriptorSetCount, | |
| const VULKAN_HPP_NAMESPACE::DescriptorSet * pDescriptorSets, | |
| uint32_t dynamicOffsetCount, | |
| const uint32_t * pDynamicOffsets, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdBindDescriptorSets( m_commandBuffer, | |
| static_cast<VkPipelineBindPoint>( pipelineBindPoint ), | |
| static_cast<VkPipelineLayout>( layout ), | |
| firstSet, | |
| descriptorSetCount, | |
| reinterpret_cast<const VkDescriptorSet *>( pDescriptorSets ), | |
| dynamicOffsetCount, | |
| pDynamicOffsets ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::bindDescriptorSets( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, | |
| VULKAN_HPP_NAMESPACE::PipelineLayout layout, | |
| uint32_t firstSet, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const & descriptorSets, | |
| ArrayProxy<const uint32_t> const & dynamicOffsets, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdBindDescriptorSets( m_commandBuffer, | |
| static_cast<VkPipelineBindPoint>( pipelineBindPoint ), | |
| static_cast<VkPipelineLayout>( layout ), | |
| firstSet, | |
| descriptorSets.size(), | |
| reinterpret_cast<const VkDescriptorSet *>( descriptorSets.data() ), | |
| dynamicOffsets.size(), | |
| dynamicOffsets.data() ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::bindIndexBuffer( VULKAN_HPP_NAMESPACE::Buffer buffer, | |
| VULKAN_HPP_NAMESPACE::DeviceSize offset, | |
| VULKAN_HPP_NAMESPACE::IndexType indexType, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdBindIndexBuffer( m_commandBuffer, | |
| static_cast<VkBuffer>( buffer ), | |
| static_cast<VkDeviceSize>( offset ), | |
| static_cast<VkIndexType>( indexType ) ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers( uint32_t firstBinding, | |
| uint32_t bindingCount, | |
| const VULKAN_HPP_NAMESPACE::Buffer * pBuffers, | |
| const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdBindVertexBuffers( m_commandBuffer, | |
| firstBinding, | |
| bindingCount, | |
| reinterpret_cast<const VkBuffer *>( pBuffers ), | |
| reinterpret_cast<const VkDeviceSize *>( pOffsets ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::bindVertexBuffers( uint32_t firstBinding, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| # ifdef VULKAN_HPP_NO_EXCEPTIONS | |
| VULKAN_HPP_ASSERT( buffers.size() == offsets.size() ); | |
| # else | |
| if ( buffers.size() != offsets.size() ) | |
| { | |
| throw LogicError( VULKAN_HPP_NAMESPACE_STRING | |
| "::CommandBuffer::bindVertexBuffers: buffers.size() != offsets.size()" ); | |
| } | |
| # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ | |
| d.vkCmdBindVertexBuffers( m_commandBuffer, | |
| firstBinding, | |
| buffers.size(), | |
| reinterpret_cast<const VkBuffer *>( buffers.data() ), | |
| reinterpret_cast<const VkDeviceSize *>( offsets.data() ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::draw( uint32_t vertexCount, | |
| uint32_t instanceCount, | |
| uint32_t firstVertex, | |
| uint32_t firstInstance, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdDraw( m_commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::drawIndexed( uint32_t indexCount, | |
| uint32_t instanceCount, | |
| uint32_t firstIndex, | |
| int32_t vertexOffset, | |
| uint32_t firstInstance, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdDrawIndexed( m_commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::drawIndirect( VULKAN_HPP_NAMESPACE::Buffer buffer, | |
| VULKAN_HPP_NAMESPACE::DeviceSize offset, | |
| uint32_t drawCount, | |
| uint32_t stride, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdDrawIndirect( | |
| m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), drawCount, stride ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirect( VULKAN_HPP_NAMESPACE::Buffer buffer, | |
| VULKAN_HPP_NAMESPACE::DeviceSize offset, | |
| uint32_t drawCount, | |
| uint32_t stride, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdDrawIndexedIndirect( | |
| m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), drawCount, stride ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::dispatch( uint32_t groupCountX, | |
| uint32_t groupCountY, | |
| uint32_t groupCountZ, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdDispatch( m_commandBuffer, groupCountX, groupCountY, groupCountZ ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::dispatchIndirect( VULKAN_HPP_NAMESPACE::Buffer buffer, | |
| VULKAN_HPP_NAMESPACE::DeviceSize offset, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdDispatchIndirect( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ) ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::copyBuffer( VULKAN_HPP_NAMESPACE::Buffer srcBuffer, | |
| VULKAN_HPP_NAMESPACE::Buffer dstBuffer, | |
| uint32_t regionCount, | |
| const VULKAN_HPP_NAMESPACE::BufferCopy * pRegions, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdCopyBuffer( m_commandBuffer, | |
| static_cast<VkBuffer>( srcBuffer ), | |
| static_cast<VkBuffer>( dstBuffer ), | |
| regionCount, | |
| reinterpret_cast<const VkBufferCopy *>( pRegions ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::copyBuffer( VULKAN_HPP_NAMESPACE::Buffer srcBuffer, | |
| VULKAN_HPP_NAMESPACE::Buffer dstBuffer, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferCopy> const & regions, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdCopyBuffer( m_commandBuffer, | |
| static_cast<VkBuffer>( srcBuffer ), | |
| static_cast<VkBuffer>( dstBuffer ), | |
| regions.size(), | |
| reinterpret_cast<const VkBufferCopy *>( regions.data() ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::copyImage( VULKAN_HPP_NAMESPACE::Image srcImage, | |
| VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, | |
| VULKAN_HPP_NAMESPACE::Image dstImage, | |
| VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, | |
| uint32_t regionCount, | |
| const VULKAN_HPP_NAMESPACE::ImageCopy * pRegions, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdCopyImage( m_commandBuffer, | |
| static_cast<VkImage>( srcImage ), | |
| static_cast<VkImageLayout>( srcImageLayout ), | |
| static_cast<VkImage>( dstImage ), | |
| static_cast<VkImageLayout>( dstImageLayout ), | |
| regionCount, | |
| reinterpret_cast<const VkImageCopy *>( pRegions ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::copyImage( VULKAN_HPP_NAMESPACE::Image srcImage, | |
| VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, | |
| VULKAN_HPP_NAMESPACE::Image dstImage, | |
| VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageCopy> const & regions, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdCopyImage( m_commandBuffer, | |
| static_cast<VkImage>( srcImage ), | |
| static_cast<VkImageLayout>( srcImageLayout ), | |
| static_cast<VkImage>( dstImage ), | |
| static_cast<VkImageLayout>( dstImageLayout ), | |
| regions.size(), | |
| reinterpret_cast<const VkImageCopy *>( regions.data() ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::blitImage( VULKAN_HPP_NAMESPACE::Image srcImage, | |
| VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, | |
| VULKAN_HPP_NAMESPACE::Image dstImage, | |
| VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, | |
| uint32_t regionCount, | |
| const VULKAN_HPP_NAMESPACE::ImageBlit * pRegions, | |
| VULKAN_HPP_NAMESPACE::Filter filter, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdBlitImage( m_commandBuffer, | |
| static_cast<VkImage>( srcImage ), | |
| static_cast<VkImageLayout>( srcImageLayout ), | |
| static_cast<VkImage>( dstImage ), | |
| static_cast<VkImageLayout>( dstImageLayout ), | |
| regionCount, | |
| reinterpret_cast<const VkImageBlit *>( pRegions ), | |
| static_cast<VkFilter>( filter ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::blitImage( VULKAN_HPP_NAMESPACE::Image srcImage, | |
| VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, | |
| VULKAN_HPP_NAMESPACE::Image dstImage, | |
| VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageBlit> const & regions, | |
| VULKAN_HPP_NAMESPACE::Filter filter, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdBlitImage( m_commandBuffer, | |
| static_cast<VkImage>( srcImage ), | |
| static_cast<VkImageLayout>( srcImageLayout ), | |
| static_cast<VkImage>( dstImage ), | |
| static_cast<VkImageLayout>( dstImageLayout ), | |
| regions.size(), | |
| reinterpret_cast<const VkImageBlit *>( regions.data() ), | |
| static_cast<VkFilter>( filter ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage( VULKAN_HPP_NAMESPACE::Buffer srcBuffer, | |
| VULKAN_HPP_NAMESPACE::Image dstImage, | |
| VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, | |
| uint32_t regionCount, | |
| const VULKAN_HPP_NAMESPACE::BufferImageCopy * pRegions, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdCopyBufferToImage( m_commandBuffer, | |
| static_cast<VkBuffer>( srcBuffer ), | |
| static_cast<VkImage>( dstImage ), | |
| static_cast<VkImageLayout>( dstImageLayout ), | |
| regionCount, | |
| reinterpret_cast<const VkBufferImageCopy *>( pRegions ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::copyBufferToImage( VULKAN_HPP_NAMESPACE::Buffer srcBuffer, | |
| VULKAN_HPP_NAMESPACE::Image dstImage, | |
| VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const & regions, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdCopyBufferToImage( m_commandBuffer, | |
| static_cast<VkBuffer>( srcBuffer ), | |
| static_cast<VkImage>( dstImage ), | |
| static_cast<VkImageLayout>( dstImageLayout ), | |
| regions.size(), | |
| reinterpret_cast<const VkBufferImageCopy *>( regions.data() ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer( VULKAN_HPP_NAMESPACE::Image srcImage, | |
| VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, | |
| VULKAN_HPP_NAMESPACE::Buffer dstBuffer, | |
| uint32_t regionCount, | |
| const VULKAN_HPP_NAMESPACE::BufferImageCopy * pRegions, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdCopyImageToBuffer( m_commandBuffer, | |
| static_cast<VkImage>( srcImage ), | |
| static_cast<VkImageLayout>( srcImageLayout ), | |
| static_cast<VkBuffer>( dstBuffer ), | |
| regionCount, | |
| reinterpret_cast<const VkBufferImageCopy *>( pRegions ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::copyImageToBuffer( VULKAN_HPP_NAMESPACE::Image srcImage, | |
| VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, | |
| VULKAN_HPP_NAMESPACE::Buffer dstBuffer, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const & regions, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdCopyImageToBuffer( m_commandBuffer, | |
| static_cast<VkImage>( srcImage ), | |
| static_cast<VkImageLayout>( srcImageLayout ), | |
| static_cast<VkBuffer>( dstBuffer ), | |
| regions.size(), | |
| reinterpret_cast<const VkBufferImageCopy *>( regions.data() ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::updateBuffer( VULKAN_HPP_NAMESPACE::Buffer dstBuffer, | |
| VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, | |
| VULKAN_HPP_NAMESPACE::DeviceSize dataSize, | |
| const void * pData, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdUpdateBuffer( m_commandBuffer, | |
| static_cast<VkBuffer>( dstBuffer ), | |
| static_cast<VkDeviceSize>( dstOffset ), | |
| static_cast<VkDeviceSize>( dataSize ), | |
| pData ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename T, typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::updateBuffer( VULKAN_HPP_NAMESPACE::Buffer dstBuffer, | |
| VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, | |
| ArrayProxy<const T> const & data, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdUpdateBuffer( m_commandBuffer, | |
| static_cast<VkBuffer>( dstBuffer ), | |
| static_cast<VkDeviceSize>( dstOffset ), | |
| data.size() * sizeof( T ), | |
| reinterpret_cast<const void *>( data.data() ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::fillBuffer( VULKAN_HPP_NAMESPACE::Buffer dstBuffer, | |
| VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, | |
| VULKAN_HPP_NAMESPACE::DeviceSize size, | |
| uint32_t data, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdFillBuffer( m_commandBuffer, | |
| static_cast<VkBuffer>( dstBuffer ), | |
| static_cast<VkDeviceSize>( dstOffset ), | |
| static_cast<VkDeviceSize>( size ), | |
| data ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::clearColorImage( VULKAN_HPP_NAMESPACE::Image image, | |
| VULKAN_HPP_NAMESPACE::ImageLayout imageLayout, | |
| const VULKAN_HPP_NAMESPACE::ClearColorValue * pColor, | |
| uint32_t rangeCount, | |
| const VULKAN_HPP_NAMESPACE::ImageSubresourceRange * pRanges, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdClearColorImage( m_commandBuffer, | |
| static_cast<VkImage>( image ), | |
| static_cast<VkImageLayout>( imageLayout ), | |
| reinterpret_cast<const VkClearColorValue *>( pColor ), | |
| rangeCount, | |
| reinterpret_cast<const VkImageSubresourceRange *>( pRanges ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::clearColorImage( VULKAN_HPP_NAMESPACE::Image image, | |
| VULKAN_HPP_NAMESPACE::ImageLayout imageLayout, | |
| const VULKAN_HPP_NAMESPACE::ClearColorValue & color, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceRange> const & ranges, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdClearColorImage( m_commandBuffer, | |
| static_cast<VkImage>( image ), | |
| static_cast<VkImageLayout>( imageLayout ), | |
| reinterpret_cast<const VkClearColorValue *>( &color ), | |
| ranges.size(), | |
| reinterpret_cast<const VkImageSubresourceRange *>( ranges.data() ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::clearDepthStencilImage( VULKAN_HPP_NAMESPACE::Image image, | |
| VULKAN_HPP_NAMESPACE::ImageLayout imageLayout, | |
| const VULKAN_HPP_NAMESPACE::ClearDepthStencilValue * pDepthStencil, | |
| uint32_t rangeCount, | |
| const VULKAN_HPP_NAMESPACE::ImageSubresourceRange * pRanges, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdClearDepthStencilImage( m_commandBuffer, | |
| static_cast<VkImage>( image ), | |
| static_cast<VkImageLayout>( imageLayout ), | |
| reinterpret_cast<const VkClearDepthStencilValue *>( pDepthStencil ), | |
| rangeCount, | |
| reinterpret_cast<const VkImageSubresourceRange *>( pRanges ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::clearDepthStencilImage( VULKAN_HPP_NAMESPACE::Image image, | |
| VULKAN_HPP_NAMESPACE::ImageLayout imageLayout, | |
| const VULKAN_HPP_NAMESPACE::ClearDepthStencilValue & depthStencil, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceRange> const & ranges, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdClearDepthStencilImage( m_commandBuffer, | |
| static_cast<VkImage>( image ), | |
| static_cast<VkImageLayout>( imageLayout ), | |
| reinterpret_cast<const VkClearDepthStencilValue *>( &depthStencil ), | |
| ranges.size(), | |
| reinterpret_cast<const VkImageSubresourceRange *>( ranges.data() ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::clearAttachments( uint32_t attachmentCount, | |
| const VULKAN_HPP_NAMESPACE::ClearAttachment * pAttachments, | |
| uint32_t rectCount, | |
| const VULKAN_HPP_NAMESPACE::ClearRect * pRects, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdClearAttachments( m_commandBuffer, | |
| attachmentCount, | |
| reinterpret_cast<const VkClearAttachment *>( pAttachments ), | |
| rectCount, | |
| reinterpret_cast<const VkClearRect *>( pRects ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::clearAttachments( ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearAttachment> const & attachments, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearRect> const & rects, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdClearAttachments( m_commandBuffer, | |
| attachments.size(), | |
| reinterpret_cast<const VkClearAttachment *>( attachments.data() ), | |
| rects.size(), | |
| reinterpret_cast<const VkClearRect *>( rects.data() ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::resolveImage( VULKAN_HPP_NAMESPACE::Image srcImage, | |
| VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, | |
| VULKAN_HPP_NAMESPACE::Image dstImage, | |
| VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, | |
| uint32_t regionCount, | |
| const VULKAN_HPP_NAMESPACE::ImageResolve * pRegions, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdResolveImage( m_commandBuffer, | |
| static_cast<VkImage>( srcImage ), | |
| static_cast<VkImageLayout>( srcImageLayout ), | |
| static_cast<VkImage>( dstImage ), | |
| static_cast<VkImageLayout>( dstImageLayout ), | |
| regionCount, | |
| reinterpret_cast<const VkImageResolve *>( pRegions ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::resolveImage( VULKAN_HPP_NAMESPACE::Image srcImage, | |
| VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, | |
| VULKAN_HPP_NAMESPACE::Image dstImage, | |
| VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageResolve> const & regions, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdResolveImage( m_commandBuffer, | |
| static_cast<VkImage>( srcImage ), | |
| static_cast<VkImageLayout>( srcImageLayout ), | |
| static_cast<VkImage>( dstImage ), | |
| static_cast<VkImageLayout>( dstImageLayout ), | |
| regions.size(), | |
| reinterpret_cast<const VkImageResolve *>( regions.data() ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setEvent( VULKAN_HPP_NAMESPACE::Event event, | |
| VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdSetEvent( m_commandBuffer, static_cast<VkEvent>( event ), static_cast<VkPipelineStageFlags>( stageMask ) ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::resetEvent( VULKAN_HPP_NAMESPACE::Event event, | |
| VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdResetEvent( m_commandBuffer, static_cast<VkEvent>( event ), static_cast<VkPipelineStageFlags>( stageMask ) ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::waitEvents( uint32_t eventCount, | |
| const VULKAN_HPP_NAMESPACE::Event * pEvents, | |
| VULKAN_HPP_NAMESPACE::PipelineStageFlags srcStageMask, | |
| VULKAN_HPP_NAMESPACE::PipelineStageFlags dstStageMask, | |
| uint32_t memoryBarrierCount, | |
| const VULKAN_HPP_NAMESPACE::MemoryBarrier * pMemoryBarriers, | |
| uint32_t bufferMemoryBarrierCount, | |
| const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier * pBufferMemoryBarriers, | |
| uint32_t imageMemoryBarrierCount, | |
| const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier * pImageMemoryBarriers, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdWaitEvents( m_commandBuffer, | |
| eventCount, | |
| reinterpret_cast<const VkEvent *>( pEvents ), | |
| static_cast<VkPipelineStageFlags>( srcStageMask ), | |
| static_cast<VkPipelineStageFlags>( dstStageMask ), | |
| memoryBarrierCount, | |
| reinterpret_cast<const VkMemoryBarrier *>( pMemoryBarriers ), | |
| bufferMemoryBarrierCount, | |
| reinterpret_cast<const VkBufferMemoryBarrier *>( pBufferMemoryBarriers ), | |
| imageMemoryBarrierCount, | |
| reinterpret_cast<const VkImageMemoryBarrier *>( pImageMemoryBarriers ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::waitEvents( ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const & events, | |
| VULKAN_HPP_NAMESPACE::PipelineStageFlags srcStageMask, | |
| VULKAN_HPP_NAMESPACE::PipelineStageFlags dstStageMask, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryBarrier> const & memoryBarriers, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> const & bufferMemoryBarriers, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> const & imageMemoryBarriers, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdWaitEvents( m_commandBuffer, | |
| events.size(), | |
| reinterpret_cast<const VkEvent *>( events.data() ), | |
| static_cast<VkPipelineStageFlags>( srcStageMask ), | |
| static_cast<VkPipelineStageFlags>( dstStageMask ), | |
| memoryBarriers.size(), | |
| reinterpret_cast<const VkMemoryBarrier *>( memoryBarriers.data() ), | |
| bufferMemoryBarriers.size(), | |
| reinterpret_cast<const VkBufferMemoryBarrier *>( bufferMemoryBarriers.data() ), | |
| imageMemoryBarriers.size(), | |
| reinterpret_cast<const VkImageMemoryBarrier *>( imageMemoryBarriers.data() ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::pipelineBarrier( VULKAN_HPP_NAMESPACE::PipelineStageFlags srcStageMask, | |
| VULKAN_HPP_NAMESPACE::PipelineStageFlags dstStageMask, | |
| VULKAN_HPP_NAMESPACE::DependencyFlags dependencyFlags, | |
| uint32_t memoryBarrierCount, | |
| const VULKAN_HPP_NAMESPACE::MemoryBarrier * pMemoryBarriers, | |
| uint32_t bufferMemoryBarrierCount, | |
| const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier * pBufferMemoryBarriers, | |
| uint32_t imageMemoryBarrierCount, | |
| const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier * pImageMemoryBarriers, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdPipelineBarrier( m_commandBuffer, | |
| static_cast<VkPipelineStageFlags>( srcStageMask ), | |
| static_cast<VkPipelineStageFlags>( dstStageMask ), | |
| static_cast<VkDependencyFlags>( dependencyFlags ), | |
| memoryBarrierCount, | |
| reinterpret_cast<const VkMemoryBarrier *>( pMemoryBarriers ), | |
| bufferMemoryBarrierCount, | |
| reinterpret_cast<const VkBufferMemoryBarrier *>( pBufferMemoryBarriers ), | |
| imageMemoryBarrierCount, | |
| reinterpret_cast<const VkImageMemoryBarrier *>( pImageMemoryBarriers ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier( | |
| VULKAN_HPP_NAMESPACE::PipelineStageFlags srcStageMask, | |
| VULKAN_HPP_NAMESPACE::PipelineStageFlags dstStageMask, | |
| VULKAN_HPP_NAMESPACE::DependencyFlags dependencyFlags, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryBarrier> const & memoryBarriers, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> const & bufferMemoryBarriers, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> const & imageMemoryBarriers, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdPipelineBarrier( m_commandBuffer, | |
| static_cast<VkPipelineStageFlags>( srcStageMask ), | |
| static_cast<VkPipelineStageFlags>( dstStageMask ), | |
| static_cast<VkDependencyFlags>( dependencyFlags ), | |
| memoryBarriers.size(), | |
| reinterpret_cast<const VkMemoryBarrier *>( memoryBarriers.data() ), | |
| bufferMemoryBarriers.size(), | |
| reinterpret_cast<const VkBufferMemoryBarrier *>( bufferMemoryBarriers.data() ), | |
| imageMemoryBarriers.size(), | |
| reinterpret_cast<const VkImageMemoryBarrier *>( imageMemoryBarriers.data() ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::beginQuery( VULKAN_HPP_NAMESPACE::QueryPool queryPool, | |
| uint32_t query, | |
| VULKAN_HPP_NAMESPACE::QueryControlFlags flags, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdBeginQuery( | |
| m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query, static_cast<VkQueryControlFlags>( flags ) ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::endQuery( VULKAN_HPP_NAMESPACE::QueryPool queryPool, | |
| uint32_t query, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdEndQuery( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::resetQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool, | |
| uint32_t firstQuery, | |
| uint32_t queryCount, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdResetQueryPool( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::writeTimestamp( VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage, | |
| VULKAN_HPP_NAMESPACE::QueryPool queryPool, | |
| uint32_t query, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdWriteTimestamp( m_commandBuffer, | |
| static_cast<VkPipelineStageFlagBits>( pipelineStage ), | |
| static_cast<VkQueryPool>( queryPool ), | |
| query ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::copyQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool queryPool, | |
| uint32_t firstQuery, | |
| uint32_t queryCount, | |
| VULKAN_HPP_NAMESPACE::Buffer dstBuffer, | |
| VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, | |
| VULKAN_HPP_NAMESPACE::DeviceSize stride, | |
| VULKAN_HPP_NAMESPACE::QueryResultFlags flags, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdCopyQueryPoolResults( m_commandBuffer, | |
| static_cast<VkQueryPool>( queryPool ), | |
| firstQuery, | |
| queryCount, | |
| static_cast<VkBuffer>( dstBuffer ), | |
| static_cast<VkDeviceSize>( dstOffset ), | |
| static_cast<VkDeviceSize>( stride ), | |
| static_cast<VkQueryResultFlags>( flags ) ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::pushConstants( VULKAN_HPP_NAMESPACE::PipelineLayout layout, | |
| VULKAN_HPP_NAMESPACE::ShaderStageFlags stageFlags, | |
| uint32_t offset, | |
| uint32_t size, | |
| const void * pValues, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdPushConstants( m_commandBuffer, | |
| static_cast<VkPipelineLayout>( layout ), | |
| static_cast<VkShaderStageFlags>( stageFlags ), | |
| offset, | |
| size, | |
| pValues ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename T, typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::pushConstants( VULKAN_HPP_NAMESPACE::PipelineLayout layout, | |
| VULKAN_HPP_NAMESPACE::ShaderStageFlags stageFlags, | |
| uint32_t offset, | |
| ArrayProxy<const T> const & values, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdPushConstants( m_commandBuffer, | |
| static_cast<VkPipelineLayout>( layout ), | |
| static_cast<VkShaderStageFlags>( stageFlags ), | |
| offset, | |
| values.size() * sizeof( T ), | |
| reinterpret_cast<const void *>( values.data() ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::beginRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo * pRenderPassBegin, | |
| VULKAN_HPP_NAMESPACE::SubpassContents contents, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdBeginRenderPass( m_commandBuffer, | |
| reinterpret_cast<const VkRenderPassBeginInfo *>( pRenderPassBegin ), | |
| static_cast<VkSubpassContents>( contents ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::beginRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin, | |
| VULKAN_HPP_NAMESPACE::SubpassContents contents, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdBeginRenderPass( m_commandBuffer, | |
| reinterpret_cast<const VkRenderPassBeginInfo *>( &renderPassBegin ), | |
| static_cast<VkSubpassContents>( contents ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::nextSubpass( VULKAN_HPP_NAMESPACE::SubpassContents contents, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdNextSubpass( m_commandBuffer, static_cast<VkSubpassContents>( contents ) ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::endRenderPass( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdEndRenderPass( m_commandBuffer ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::executeCommands( uint32_t commandBufferCount, | |
| const VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdExecuteCommands( | |
| m_commandBuffer, commandBufferCount, reinterpret_cast<const VkCommandBuffer *>( pCommandBuffers ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::executeCommands( ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdExecuteCommands( | |
| m_commandBuffer, commandBuffers.size(), reinterpret_cast<const VkCommandBuffer *>( commandBuffers.data() ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_VERSION_1_1 === | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result enumerateInstanceVersion( uint32_t * pApiVersion, | |
| Dispatch const & d ) VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkEnumerateInstanceVersion( pApiVersion ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE typename ResultValueType<uint32_t>::type enumerateInstanceVersion( Dispatch const & d ) | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| uint32_t apiVersion; | |
| Result result = static_cast<Result>( d.vkEnumerateInstanceVersion( &apiVersion ) ); | |
| return createResultValue( result, apiVersion, VULKAN_HPP_NAMESPACE_STRING "::enumerateInstanceVersion" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::bindBufferMemory2( uint32_t bindInfoCount, | |
| const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo * pBindInfos, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkBindBufferMemory2( | |
| m_device, bindInfoCount, reinterpret_cast<const VkBindBufferMemoryInfo *>( pBindInfos ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| Device::bindBufferMemory2( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const & bindInfos, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| Result result = static_cast<Result>( d.vkBindBufferMemory2( | |
| m_device, bindInfos.size(), reinterpret_cast<const VkBindBufferMemoryInfo *>( bindInfos.data() ) ) ); | |
| return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindBufferMemory2" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::bindImageMemory2( uint32_t bindInfoCount, | |
| const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo * pBindInfos, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkBindImageMemory2( m_device, bindInfoCount, reinterpret_cast<const VkBindImageMemoryInfo *>( pBindInfos ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| Device::bindImageMemory2( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const & bindInfos, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| Result result = static_cast<Result>( d.vkBindImageMemory2( | |
| m_device, bindInfos.size(), reinterpret_cast<const VkBindImageMemoryInfo *>( bindInfos.data() ) ) ); | |
| return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindImageMemory2" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| Device::getGroupPeerMemoryFeatures( uint32_t heapIndex, | |
| uint32_t localDeviceIndex, | |
| uint32_t remoteDeviceIndex, | |
| VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags * pPeerMemoryFeatures, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkGetDeviceGroupPeerMemoryFeatures( m_device, | |
| heapIndex, | |
| localDeviceIndex, | |
| remoteDeviceIndex, | |
| reinterpret_cast<VkPeerMemoryFeatureFlags *>( pPeerMemoryFeatures ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags | |
| Device::getGroupPeerMemoryFeatures( uint32_t heapIndex, | |
| uint32_t localDeviceIndex, | |
| uint32_t remoteDeviceIndex, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags peerMemoryFeatures; | |
| d.vkGetDeviceGroupPeerMemoryFeatures( m_device, | |
| heapIndex, | |
| localDeviceIndex, | |
| remoteDeviceIndex, | |
| reinterpret_cast<VkPeerMemoryFeatureFlags *>( &peerMemoryFeatures ) ); | |
| return peerMemoryFeatures; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setDeviceMask( uint32_t deviceMask, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdSetDeviceMask( m_commandBuffer, deviceMask ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::dispatchBase( uint32_t baseGroupX, | |
| uint32_t baseGroupY, | |
| uint32_t baseGroupZ, | |
| uint32_t groupCountX, | |
| uint32_t groupCountY, | |
| uint32_t groupCountZ, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdDispatchBase( m_commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::enumeratePhysicalDeviceGroups( | |
| uint32_t * pPhysicalDeviceGroupCount, | |
| VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkEnumeratePhysicalDeviceGroups( | |
| m_instance, | |
| pPhysicalDeviceGroupCount, | |
| reinterpret_cast<VkPhysicalDeviceGroupProperties *>( pPhysicalDeviceGroupProperties ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename PhysicalDeviceGroupPropertiesAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE | |
| typename ResultValueType<std::vector<PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type | |
| Instance::enumeratePhysicalDeviceGroups( Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator> physicalDeviceGroupProperties; | |
| uint32_t physicalDeviceGroupCount; | |
| Result result; | |
| do | |
| { | |
| result = | |
| static_cast<Result>( d.vkEnumeratePhysicalDeviceGroups( m_instance, &physicalDeviceGroupCount, nullptr ) ); | |
| if ( ( result == Result::eSuccess ) && physicalDeviceGroupCount ) | |
| { | |
| physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); | |
| result = static_cast<Result>( d.vkEnumeratePhysicalDeviceGroups( | |
| m_instance, | |
| &physicalDeviceGroupCount, | |
| reinterpret_cast<VkPhysicalDeviceGroupProperties *>( physicalDeviceGroupProperties.data() ) ) ); | |
| VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() ); | |
| } | |
| } while ( result == Result::eIncomplete ); | |
| if ( ( result == Result::eSuccess ) && ( physicalDeviceGroupCount < physicalDeviceGroupProperties.size() ) ) | |
| { | |
| physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); | |
| } | |
| return createResultValue( | |
| result, physicalDeviceGroupProperties, VULKAN_HPP_NAMESPACE_STRING "::Instance::enumeratePhysicalDeviceGroups" ); | |
| } | |
| template < | |
| typename PhysicalDeviceGroupPropertiesAllocator, | |
| typename Dispatch, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, PhysicalDeviceGroupProperties>::value, int>::type> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE | |
| typename ResultValueType<std::vector<PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type | |
| Instance::enumeratePhysicalDeviceGroups( | |
| PhysicalDeviceGroupPropertiesAllocator & physicalDeviceGroupPropertiesAllocator, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator> physicalDeviceGroupProperties( | |
| physicalDeviceGroupPropertiesAllocator ); | |
| uint32_t physicalDeviceGroupCount; | |
| Result result; | |
| do | |
| { | |
| result = | |
| static_cast<Result>( d.vkEnumeratePhysicalDeviceGroups( m_instance, &physicalDeviceGroupCount, nullptr ) ); | |
| if ( ( result == Result::eSuccess ) && physicalDeviceGroupCount ) | |
| { | |
| physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); | |
| result = static_cast<Result>( d.vkEnumeratePhysicalDeviceGroups( | |
| m_instance, | |
| &physicalDeviceGroupCount, | |
| reinterpret_cast<VkPhysicalDeviceGroupProperties *>( physicalDeviceGroupProperties.data() ) ) ); | |
| VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() ); | |
| } | |
| } while ( result == Result::eIncomplete ); | |
| if ( ( result == Result::eSuccess ) && ( physicalDeviceGroupCount < physicalDeviceGroupProperties.size() ) ) | |
| { | |
| physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); | |
| } | |
| return createResultValue( | |
| result, physicalDeviceGroupProperties, VULKAN_HPP_NAMESPACE_STRING "::Instance::enumeratePhysicalDeviceGroups" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| Device::getImageMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 * pInfo, | |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkGetImageMemoryRequirements2( m_device, | |
| reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>( pInfo ), | |
| reinterpret_cast<VkMemoryRequirements2 *>( pMemoryRequirements ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2 | |
| Device::getImageMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements; | |
| d.vkGetImageMemoryRequirements2( m_device, | |
| reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>( &info ), | |
| reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) ); | |
| return memoryRequirements; | |
| } | |
| template <typename X, typename Y, typename... Z, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> | |
| Device::getImageMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| StructureChain<X, Y, Z...> structureChain; | |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements = | |
| structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>(); | |
| d.vkGetImageMemoryRequirements2( m_device, | |
| reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>( &info ), | |
| reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) ); | |
| return structureChain; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| Device::getBufferMemoryRequirements2( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 * pInfo, | |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkGetBufferMemoryRequirements2( m_device, | |
| reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>( pInfo ), | |
| reinterpret_cast<VkMemoryRequirements2 *>( pMemoryRequirements ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2 | |
| Device::getBufferMemoryRequirements2( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements; | |
| d.vkGetBufferMemoryRequirements2( m_device, | |
| reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>( &info ), | |
| reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) ); | |
| return memoryRequirements; | |
| } | |
| template <typename X, typename Y, typename... Z, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> | |
| Device::getBufferMemoryRequirements2( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| StructureChain<X, Y, Z...> structureChain; | |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements = | |
| structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>(); | |
| d.vkGetBufferMemoryRequirements2( m_device, | |
| reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>( &info ), | |
| reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) ); | |
| return structureChain; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirements2( | |
| const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 * pInfo, | |
| uint32_t * pSparseMemoryRequirementCount, | |
| VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 * pSparseMemoryRequirements, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkGetImageSparseMemoryRequirements2( | |
| m_device, | |
| reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( pInfo ), | |
| pSparseMemoryRequirementCount, | |
| reinterpret_cast<VkSparseImageMemoryRequirements2 *>( pSparseMemoryRequirements ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename SparseImageMemoryRequirements2Allocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD | |
| VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> | |
| Device::getImageSparseMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> sparseMemoryRequirements; | |
| uint32_t sparseMemoryRequirementCount; | |
| d.vkGetImageSparseMemoryRequirements2( m_device, | |
| reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ), | |
| &sparseMemoryRequirementCount, | |
| nullptr ); | |
| sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); | |
| d.vkGetImageSparseMemoryRequirements2( | |
| m_device, | |
| reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ), | |
| &sparseMemoryRequirementCount, | |
| reinterpret_cast<VkSparseImageMemoryRequirements2 *>( sparseMemoryRequirements.data() ) ); | |
| VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() ); | |
| return sparseMemoryRequirements; | |
| } | |
| template < | |
| typename SparseImageMemoryRequirements2Allocator, | |
| typename Dispatch, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, SparseImageMemoryRequirements2>::value, int>::type> | |
| VULKAN_HPP_NODISCARD | |
| VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> | |
| Device::getImageSparseMemoryRequirements2( | |
| const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info, | |
| SparseImageMemoryRequirements2Allocator & sparseImageMemoryRequirements2Allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> sparseMemoryRequirements( | |
| sparseImageMemoryRequirements2Allocator ); | |
| uint32_t sparseMemoryRequirementCount; | |
| d.vkGetImageSparseMemoryRequirements2( m_device, | |
| reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ), | |
| &sparseMemoryRequirementCount, | |
| nullptr ); | |
| sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); | |
| d.vkGetImageSparseMemoryRequirements2( | |
| m_device, | |
| reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ), | |
| &sparseMemoryRequirementCount, | |
| reinterpret_cast<VkSparseImageMemoryRequirements2 *>( sparseMemoryRequirements.data() ) ); | |
| VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() ); | |
| return sparseMemoryRequirements; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void PhysicalDevice::getFeatures2( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 * pFeatures, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkGetPhysicalDeviceFeatures2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2 *>( pFeatures ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 | |
| PhysicalDevice::getFeatures2( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 features; | |
| d.vkGetPhysicalDeviceFeatures2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2 *>( &features ) ); | |
| return features; | |
| } | |
| template <typename X, typename Y, typename... Z, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> | |
| PhysicalDevice::getFeatures2( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| StructureChain<X, Y, Z...> structureChain; | |
| VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 & features = | |
| structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2>(); | |
| d.vkGetPhysicalDeviceFeatures2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2 *>( &features ) ); | |
| return structureChain; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void PhysicalDevice::getProperties2( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 * pProperties, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkGetPhysicalDeviceProperties2( m_physicalDevice, | |
| reinterpret_cast<VkPhysicalDeviceProperties2 *>( pProperties ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 | |
| PhysicalDevice::getProperties2( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 properties; | |
| d.vkGetPhysicalDeviceProperties2( m_physicalDevice, | |
| reinterpret_cast<VkPhysicalDeviceProperties2 *>( &properties ) ); | |
| return properties; | |
| } | |
| template <typename X, typename Y, typename... Z, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> | |
| PhysicalDevice::getProperties2( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| StructureChain<X, Y, Z...> structureChain; | |
| VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 & properties = | |
| structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2>(); | |
| d.vkGetPhysicalDeviceProperties2( m_physicalDevice, | |
| reinterpret_cast<VkPhysicalDeviceProperties2 *>( &properties ) ); | |
| return structureChain; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| PhysicalDevice::getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format, | |
| VULKAN_HPP_NAMESPACE::FormatProperties2 * pFormatProperties, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkGetPhysicalDeviceFormatProperties2( | |
| m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2 *>( pFormatProperties ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::FormatProperties2 | |
| PhysicalDevice::getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::FormatProperties2 formatProperties; | |
| d.vkGetPhysicalDeviceFormatProperties2( | |
| m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2 *>( &formatProperties ) ); | |
| return formatProperties; | |
| } | |
| template <typename X, typename Y, typename... Z, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> | |
| PhysicalDevice::getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| StructureChain<X, Y, Z...> structureChain; | |
| VULKAN_HPP_NAMESPACE::FormatProperties2 & formatProperties = | |
| structureChain.template get<VULKAN_HPP_NAMESPACE::FormatProperties2>(); | |
| d.vkGetPhysicalDeviceFormatProperties2( | |
| m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2 *>( &formatProperties ) ); | |
| return structureChain; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getImageFormatProperties2( | |
| const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 * pImageFormatInfo, | |
| VULKAN_HPP_NAMESPACE::ImageFormatProperties2 * pImageFormatProperties, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2( | |
| m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>( pImageFormatInfo ), | |
| reinterpret_cast<VkImageFormatProperties2 *>( pImageFormatProperties ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>::type | |
| PhysicalDevice::getImageFormatProperties2( | |
| const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::ImageFormatProperties2 imageFormatProperties; | |
| Result result = static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2( | |
| m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>( &imageFormatInfo ), | |
| reinterpret_cast<VkImageFormatProperties2 *>( &imageFormatProperties ) ) ); | |
| return createResultValue( | |
| result, imageFormatProperties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2" ); | |
| } | |
| template <typename X, typename Y, typename... Z, typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<StructureChain<X, Y, Z...>>::type | |
| PhysicalDevice::getImageFormatProperties2( | |
| const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| StructureChain<X, Y, Z...> structureChain; | |
| VULKAN_HPP_NAMESPACE::ImageFormatProperties2 & imageFormatProperties = | |
| structureChain.template get<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>(); | |
| Result result = static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2( | |
| m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>( &imageFormatInfo ), | |
| reinterpret_cast<VkImageFormatProperties2 *>( &imageFormatProperties ) ) ); | |
| return createResultValue( | |
| result, structureChain, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| PhysicalDevice::getQueueFamilyProperties2( uint32_t * pQueueFamilyPropertyCount, | |
| VULKAN_HPP_NAMESPACE::QueueFamilyProperties2 * pQueueFamilyProperties, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkGetPhysicalDeviceQueueFamilyProperties2( | |
| m_physicalDevice, | |
| pQueueFamilyPropertyCount, | |
| reinterpret_cast<VkQueueFamilyProperties2 *>( pQueueFamilyProperties ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename QueueFamilyProperties2Allocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator> | |
| PhysicalDevice::getQueueFamilyProperties2( Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator> queueFamilyProperties; | |
| uint32_t queueFamilyPropertyCount; | |
| d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, nullptr ); | |
| queueFamilyProperties.resize( queueFamilyPropertyCount ); | |
| d.vkGetPhysicalDeviceQueueFamilyProperties2( | |
| m_physicalDevice, | |
| &queueFamilyPropertyCount, | |
| reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) ); | |
| VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() ); | |
| return queueFamilyProperties; | |
| } | |
| template <typename QueueFamilyProperties2Allocator, | |
| typename Dispatch, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, QueueFamilyProperties2>::value, int>::type> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator> | |
| PhysicalDevice::getQueueFamilyProperties2( QueueFamilyProperties2Allocator & queueFamilyProperties2Allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator> queueFamilyProperties( | |
| queueFamilyProperties2Allocator ); | |
| uint32_t queueFamilyPropertyCount; | |
| d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, nullptr ); | |
| queueFamilyProperties.resize( queueFamilyPropertyCount ); | |
| d.vkGetPhysicalDeviceQueueFamilyProperties2( | |
| m_physicalDevice, | |
| &queueFamilyPropertyCount, | |
| reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) ); | |
| VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() ); | |
| return queueFamilyProperties; | |
| } | |
| template <typename StructureChain, typename StructureChainAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<StructureChain, StructureChainAllocator> | |
| PhysicalDevice::getQueueFamilyProperties2( Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| uint32_t queueFamilyPropertyCount; | |
| d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, nullptr ); | |
| std::vector<StructureChain, StructureChainAllocator> returnVector( queueFamilyPropertyCount ); | |
| std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> queueFamilyProperties( queueFamilyPropertyCount ); | |
| for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ ) | |
| { | |
| queueFamilyProperties[i].pNext = | |
| returnVector[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>().pNext; | |
| } | |
| d.vkGetPhysicalDeviceQueueFamilyProperties2( | |
| m_physicalDevice, | |
| &queueFamilyPropertyCount, | |
| reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) ); | |
| VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() ); | |
| for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ ) | |
| { | |
| returnVector[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>() = queueFamilyProperties[i]; | |
| } | |
| return returnVector; | |
| } | |
| template <typename StructureChain, | |
| typename StructureChainAllocator, | |
| typename Dispatch, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, StructureChain>::value, int>::type> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<StructureChain, StructureChainAllocator> | |
| PhysicalDevice::getQueueFamilyProperties2( StructureChainAllocator & structureChainAllocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| uint32_t queueFamilyPropertyCount; | |
| d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, nullptr ); | |
| std::vector<StructureChain, StructureChainAllocator> returnVector( queueFamilyPropertyCount, | |
| structureChainAllocator ); | |
| std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> queueFamilyProperties( queueFamilyPropertyCount ); | |
| for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ ) | |
| { | |
| queueFamilyProperties[i].pNext = | |
| returnVector[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>().pNext; | |
| } | |
| d.vkGetPhysicalDeviceQueueFamilyProperties2( | |
| m_physicalDevice, | |
| &queueFamilyPropertyCount, | |
| reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) ); | |
| VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() ); | |
| for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ ) | |
| { | |
| returnVector[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>() = queueFamilyProperties[i]; | |
| } | |
| return returnVector; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| PhysicalDevice::getMemoryProperties2( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 * pMemoryProperties, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkGetPhysicalDeviceMemoryProperties2( | |
| m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>( pMemoryProperties ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 | |
| PhysicalDevice::getMemoryProperties2( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 memoryProperties; | |
| d.vkGetPhysicalDeviceMemoryProperties2( | |
| m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>( &memoryProperties ) ); | |
| return memoryProperties; | |
| } | |
| template <typename X, typename Y, typename... Z, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> | |
| PhysicalDevice::getMemoryProperties2( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| StructureChain<X, Y, Z...> structureChain; | |
| VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 & memoryProperties = | |
| structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2>(); | |
| d.vkGetPhysicalDeviceMemoryProperties2( | |
| m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>( &memoryProperties ) ); | |
| return structureChain; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void PhysicalDevice::getSparseImageFormatProperties2( | |
| const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 * pFormatInfo, | |
| uint32_t * pPropertyCount, | |
| VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 * pProperties, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkGetPhysicalDeviceSparseImageFormatProperties2( | |
| m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( pFormatInfo ), | |
| pPropertyCount, | |
| reinterpret_cast<VkSparseImageFormatProperties2 *>( pProperties ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename SparseImageFormatProperties2Allocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD | |
| VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator> | |
| PhysicalDevice::getSparseImageFormatProperties2( | |
| const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator> properties; | |
| uint32_t propertyCount; | |
| d.vkGetPhysicalDeviceSparseImageFormatProperties2( | |
| m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ), | |
| &propertyCount, | |
| nullptr ); | |
| properties.resize( propertyCount ); | |
| d.vkGetPhysicalDeviceSparseImageFormatProperties2( | |
| m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ), | |
| &propertyCount, | |
| reinterpret_cast<VkSparseImageFormatProperties2 *>( properties.data() ) ); | |
| VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); | |
| return properties; | |
| } | |
| template < | |
| typename SparseImageFormatProperties2Allocator, | |
| typename Dispatch, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, SparseImageFormatProperties2>::value, int>::type> | |
| VULKAN_HPP_NODISCARD | |
| VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator> | |
| PhysicalDevice::getSparseImageFormatProperties2( | |
| const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo, | |
| SparseImageFormatProperties2Allocator & sparseImageFormatProperties2Allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator> properties( | |
| sparseImageFormatProperties2Allocator ); | |
| uint32_t propertyCount; | |
| d.vkGetPhysicalDeviceSparseImageFormatProperties2( | |
| m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ), | |
| &propertyCount, | |
| nullptr ); | |
| properties.resize( propertyCount ); | |
| d.vkGetPhysicalDeviceSparseImageFormatProperties2( | |
| m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ), | |
| &propertyCount, | |
| reinterpret_cast<VkSparseImageFormatProperties2 *>( properties.data() ) ); | |
| VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); | |
| return properties; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::trimCommandPool( VULKAN_HPP_NAMESPACE::CommandPool commandPool, | |
| VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkTrimCommandPool( | |
| m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolTrimFlags>( flags ) ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::getQueue2( const VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 * pQueueInfo, | |
| VULKAN_HPP_NAMESPACE::Queue * pQueue, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkGetDeviceQueue2( | |
| m_device, reinterpret_cast<const VkDeviceQueueInfo2 *>( pQueueInfo ), reinterpret_cast<VkQueue *>( pQueue ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Queue | |
| Device::getQueue2( const VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 & queueInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::Queue queue; | |
| d.vkGetDeviceQueue2( | |
| m_device, reinterpret_cast<const VkDeviceQueueInfo2 *>( &queueInfo ), reinterpret_cast<VkQueue *>( &queue ) ); | |
| return queue; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::createSamplerYcbcrConversion( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo * pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion * pYcbcrConversion, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkCreateSamplerYcbcrConversion( m_device, | |
| reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo *>( pCreateInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), | |
| reinterpret_cast<VkSamplerYcbcrConversion *>( pYcbcrConversion ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>::type | |
| Device::createSamplerYcbcrConversion( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo & createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion; | |
| Result result = static_cast<Result>( | |
| d.vkCreateSamplerYcbcrConversion( m_device, | |
| reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkSamplerYcbcrConversion *>( &ycbcrConversion ) ) ); | |
| return createResultValue( | |
| result, ycbcrConversion, VULKAN_HPP_NAMESPACE_STRING "::Device::createSamplerYcbcrConversion" ); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion, Dispatch>>::type | |
| Device::createSamplerYcbcrConversionUnique( | |
| const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo & createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion; | |
| Result result = static_cast<Result>( | |
| d.vkCreateSamplerYcbcrConversion( m_device, | |
| reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkSamplerYcbcrConversion *>( &ycbcrConversion ) ) ); | |
| ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d ); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion, Dispatch>( | |
| result, ycbcrConversion, VULKAN_HPP_NAMESPACE_STRING "::Device::createSamplerYcbcrConversionUnique", deleter ); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| Device::destroySamplerYcbcrConversion( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroySamplerYcbcrConversion( m_device, | |
| static_cast<VkSamplerYcbcrConversion>( ycbcrConversion ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| Device::destroySamplerYcbcrConversion( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroySamplerYcbcrConversion( | |
| m_device, | |
| static_cast<VkSamplerYcbcrConversion>( ycbcrConversion ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroySamplerYcbcrConversion( m_device, | |
| static_cast<VkSamplerYcbcrConversion>( ycbcrConversion ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroySamplerYcbcrConversion( | |
| m_device, | |
| static_cast<VkSamplerYcbcrConversion>( ycbcrConversion ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createDescriptorUpdateTemplate( | |
| const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo * pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate * pDescriptorUpdateTemplate, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkCreateDescriptorUpdateTemplate( | |
| m_device, | |
| reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo *>( pCreateInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), | |
| reinterpret_cast<VkDescriptorUpdateTemplate *>( pDescriptorUpdateTemplate ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate>::type | |
| Device::createDescriptorUpdateTemplate( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo & createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate; | |
| Result result = static_cast<Result>( d.vkCreateDescriptorUpdateTemplate( | |
| m_device, | |
| reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkDescriptorUpdateTemplate *>( &descriptorUpdateTemplate ) ) ); | |
| return createResultValue( | |
| result, descriptorUpdateTemplate, VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorUpdateTemplate" ); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate, Dispatch>>::type | |
| Device::createDescriptorUpdateTemplateUnique( | |
| const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo & createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate; | |
| Result result = static_cast<Result>( d.vkCreateDescriptorUpdateTemplate( | |
| m_device, | |
| reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkDescriptorUpdateTemplate *>( &descriptorUpdateTemplate ) ) ); | |
| ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d ); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate, Dispatch>( | |
| result, | |
| descriptorUpdateTemplate, | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorUpdateTemplateUnique", | |
| deleter ); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| Device::destroyDescriptorUpdateTemplate( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyDescriptorUpdateTemplate( m_device, | |
| static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| Device::destroyDescriptorUpdateTemplate( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyDescriptorUpdateTemplate( | |
| m_device, | |
| static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyDescriptorUpdateTemplate( m_device, | |
| static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyDescriptorUpdateTemplate( | |
| m_device, | |
| static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| Device::updateDescriptorSetWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet, | |
| VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, | |
| const void * pData, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkUpdateDescriptorSetWithTemplate( m_device, | |
| static_cast<VkDescriptorSet>( descriptorSet ), | |
| static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), | |
| pData ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void PhysicalDevice::getExternalBufferProperties( | |
| const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo * pExternalBufferInfo, | |
| VULKAN_HPP_NAMESPACE::ExternalBufferProperties * pExternalBufferProperties, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkGetPhysicalDeviceExternalBufferProperties( | |
| m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo *>( pExternalBufferInfo ), | |
| reinterpret_cast<VkExternalBufferProperties *>( pExternalBufferProperties ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalBufferProperties | |
| PhysicalDevice::getExternalBufferProperties( | |
| const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo & externalBufferInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::ExternalBufferProperties externalBufferProperties; | |
| d.vkGetPhysicalDeviceExternalBufferProperties( | |
| m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo *>( &externalBufferInfo ), | |
| reinterpret_cast<VkExternalBufferProperties *>( &externalBufferProperties ) ); | |
| return externalBufferProperties; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void PhysicalDevice::getExternalFenceProperties( | |
| const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo * pExternalFenceInfo, | |
| VULKAN_HPP_NAMESPACE::ExternalFenceProperties * pExternalFenceProperties, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkGetPhysicalDeviceExternalFenceProperties( | |
| m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo *>( pExternalFenceInfo ), | |
| reinterpret_cast<VkExternalFenceProperties *>( pExternalFenceProperties ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalFenceProperties | |
| PhysicalDevice::getExternalFenceProperties( | |
| const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo & externalFenceInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::ExternalFenceProperties externalFenceProperties; | |
| d.vkGetPhysicalDeviceExternalFenceProperties( | |
| m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo *>( &externalFenceInfo ), | |
| reinterpret_cast<VkExternalFenceProperties *>( &externalFenceProperties ) ); | |
| return externalFenceProperties; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void PhysicalDevice::getExternalSemaphoreProperties( | |
| const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo, | |
| VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties * pExternalSemaphoreProperties, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkGetPhysicalDeviceExternalSemaphoreProperties( | |
| m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo *>( pExternalSemaphoreInfo ), | |
| reinterpret_cast<VkExternalSemaphoreProperties *>( pExternalSemaphoreProperties ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties | |
| PhysicalDevice::getExternalSemaphoreProperties( | |
| const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties externalSemaphoreProperties; | |
| d.vkGetPhysicalDeviceExternalSemaphoreProperties( | |
| m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo *>( &externalSemaphoreInfo ), | |
| reinterpret_cast<VkExternalSemaphoreProperties *>( &externalSemaphoreProperties ) ); | |
| return externalSemaphoreProperties; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| Device::getDescriptorSetLayoutSupport( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo * pCreateInfo, | |
| VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport * pSupport, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkGetDescriptorSetLayoutSupport( m_device, | |
| reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( pCreateInfo ), | |
| reinterpret_cast<VkDescriptorSetLayoutSupport *>( pSupport ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport | |
| Device::getDescriptorSetLayoutSupport( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport support; | |
| d.vkGetDescriptorSetLayoutSupport( m_device, | |
| reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( &createInfo ), | |
| reinterpret_cast<VkDescriptorSetLayoutSupport *>( &support ) ); | |
| return support; | |
| } | |
| template <typename X, typename Y, typename... Z, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> | |
| Device::getDescriptorSetLayoutSupport( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| StructureChain<X, Y, Z...> structureChain; | |
| VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport & support = | |
| structureChain.template get<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport>(); | |
| d.vkGetDescriptorSetLayoutSupport( m_device, | |
| reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( &createInfo ), | |
| reinterpret_cast<VkDescriptorSetLayoutSupport *>( &support ) ); | |
| return structureChain; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_VERSION_1_2 === | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCount( VULKAN_HPP_NAMESPACE::Buffer buffer, | |
| VULKAN_HPP_NAMESPACE::DeviceSize offset, | |
| VULKAN_HPP_NAMESPACE::Buffer countBuffer, | |
| VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, | |
| uint32_t maxDrawCount, | |
| uint32_t stride, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdDrawIndirectCount( m_commandBuffer, | |
| static_cast<VkBuffer>( buffer ), | |
| static_cast<VkDeviceSize>( offset ), | |
| static_cast<VkBuffer>( countBuffer ), | |
| static_cast<VkDeviceSize>( countBufferOffset ), | |
| maxDrawCount, | |
| stride ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCount( VULKAN_HPP_NAMESPACE::Buffer buffer, | |
| VULKAN_HPP_NAMESPACE::DeviceSize offset, | |
| VULKAN_HPP_NAMESPACE::Buffer countBuffer, | |
| VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, | |
| uint32_t maxDrawCount, | |
| uint32_t stride, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdDrawIndexedIndirectCount( m_commandBuffer, | |
| static_cast<VkBuffer>( buffer ), | |
| static_cast<VkDeviceSize>( offset ), | |
| static_cast<VkBuffer>( countBuffer ), | |
| static_cast<VkDeviceSize>( countBufferOffset ), | |
| maxDrawCount, | |
| stride ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::createRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 * pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| VULKAN_HPP_NAMESPACE::RenderPass * pRenderPass, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkCreateRenderPass2( m_device, | |
| reinterpret_cast<const VkRenderPassCreateInfo2 *>( pCreateInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), | |
| reinterpret_cast<VkRenderPass *>( pRenderPass ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<VULKAN_HPP_NAMESPACE::RenderPass>::type | |
| Device::createRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 & createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::RenderPass renderPass; | |
| Result result = static_cast<Result>( | |
| d.vkCreateRenderPass2( m_device, | |
| reinterpret_cast<const VkRenderPassCreateInfo2 *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkRenderPass *>( &renderPass ) ) ); | |
| return createResultValue( result, renderPass, VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPass2" ); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>>::type | |
| Device::createRenderPass2Unique( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 & createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::RenderPass renderPass; | |
| Result result = static_cast<Result>( | |
| d.vkCreateRenderPass2( m_device, | |
| reinterpret_cast<const VkRenderPassCreateInfo2 *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkRenderPass *>( &renderPass ) ) ); | |
| ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d ); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>( | |
| result, renderPass, VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPass2Unique", deleter ); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::beginRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo * pRenderPassBegin, | |
| const VULKAN_HPP_NAMESPACE::SubpassBeginInfo * pSubpassBeginInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdBeginRenderPass2( m_commandBuffer, | |
| reinterpret_cast<const VkRenderPassBeginInfo *>( pRenderPassBegin ), | |
| reinterpret_cast<const VkSubpassBeginInfo *>( pSubpassBeginInfo ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::beginRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin, | |
| const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdBeginRenderPass2( m_commandBuffer, | |
| reinterpret_cast<const VkRenderPassBeginInfo *>( &renderPassBegin ), | |
| reinterpret_cast<const VkSubpassBeginInfo *>( &subpassBeginInfo ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::nextSubpass2( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo * pSubpassBeginInfo, | |
| const VULKAN_HPP_NAMESPACE::SubpassEndInfo * pSubpassEndInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdNextSubpass2( m_commandBuffer, | |
| reinterpret_cast<const VkSubpassBeginInfo *>( pSubpassBeginInfo ), | |
| reinterpret_cast<const VkSubpassEndInfo *>( pSubpassEndInfo ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::nextSubpass2( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo, | |
| const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdNextSubpass2( m_commandBuffer, | |
| reinterpret_cast<const VkSubpassBeginInfo *>( &subpassBeginInfo ), | |
| reinterpret_cast<const VkSubpassEndInfo *>( &subpassEndInfo ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::endRenderPass2( const VULKAN_HPP_NAMESPACE::SubpassEndInfo * pSubpassEndInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdEndRenderPass2( m_commandBuffer, reinterpret_cast<const VkSubpassEndInfo *>( pSubpassEndInfo ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::endRenderPass2( const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdEndRenderPass2( m_commandBuffer, reinterpret_cast<const VkSubpassEndInfo *>( &subpassEndInfo ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::resetQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool, | |
| uint32_t firstQuery, | |
| uint32_t queryCount, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkResetQueryPool( m_device, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSemaphoreCounterValue( | |
| VULKAN_HPP_NAMESPACE::Semaphore semaphore, uint64_t * pValue, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkGetSemaphoreCounterValue( m_device, static_cast<VkSemaphore>( semaphore ), pValue ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<uint64_t>::type | |
| Device::getSemaphoreCounterValue( VULKAN_HPP_NAMESPACE::Semaphore semaphore, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| uint64_t value; | |
| Result result = | |
| static_cast<Result>( d.vkGetSemaphoreCounterValue( m_device, static_cast<VkSemaphore>( semaphore ), &value ) ); | |
| return createResultValue( result, value, VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreCounterValue" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::waitSemaphores( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo * pWaitInfo, | |
| uint64_t timeout, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkWaitSemaphores( m_device, reinterpret_cast<const VkSemaphoreWaitInfo *>( pWaitInfo ), timeout ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::waitSemaphores( | |
| const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo & waitInfo, uint64_t timeout, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| Result result = static_cast<Result>( | |
| d.vkWaitSemaphores( m_device, reinterpret_cast<const VkSemaphoreWaitInfo *>( &waitInfo ), timeout ) ); | |
| return createResultValue( result, | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::waitSemaphores", | |
| { 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::signalSemaphore( | |
| const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo * pSignalInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkSignalSemaphore( m_device, reinterpret_cast<const VkSemaphoreSignalInfo *>( pSignalInfo ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| Device::signalSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo & signalInfo, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| Result result = static_cast<Result>( | |
| d.vkSignalSemaphore( m_device, reinterpret_cast<const VkSemaphoreSignalInfo *>( &signalInfo ) ) ); | |
| return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::signalSemaphore" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<DeviceAddress>( | |
| d.vkGetBufferDeviceAddress( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo *>( pInfo ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return d.vkGetBufferDeviceAddress( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo *>( &info ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE uint64_t Device::getBufferOpaqueCaptureAddress( | |
| const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return d.vkGetBufferOpaqueCaptureAddress( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo *>( pInfo ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE uint64_t Device::getBufferOpaqueCaptureAddress( | |
| const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return d.vkGetBufferOpaqueCaptureAddress( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo *>( &info ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE uint64_t | |
| Device::getMemoryOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo * pInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return d.vkGetDeviceMemoryOpaqueCaptureAddress( | |
| m_device, reinterpret_cast<const VkDeviceMemoryOpaqueCaptureAddressInfo *>( pInfo ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE uint64_t | |
| Device::getMemoryOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo & info, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return d.vkGetDeviceMemoryOpaqueCaptureAddress( | |
| m_device, reinterpret_cast<const VkDeviceMemoryOpaqueCaptureAddressInfo *>( &info ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_KHR_surface === | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Instance::destroySurfaceKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroySurfaceKHR( | |
| m_instance, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| Instance::destroySurfaceKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroySurfaceKHR( m_instance, | |
| static_cast<VkSurfaceKHR>( surface ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Instance::destroy( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroySurfaceKHR( | |
| m_instance, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Instance::destroy( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroySurfaceKHR( m_instance, | |
| static_cast<VkSurfaceKHR>( surface ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| PhysicalDevice::getSurfaceSupportKHR( uint32_t queueFamilyIndex, | |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface, | |
| VULKAN_HPP_NAMESPACE::Bool32 * pSupported, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkGetPhysicalDeviceSurfaceSupportKHR( m_physicalDevice, | |
| queueFamilyIndex, | |
| static_cast<VkSurfaceKHR>( surface ), | |
| reinterpret_cast<VkBool32 *>( pSupported ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::Bool32>::type | |
| PhysicalDevice::getSurfaceSupportKHR( uint32_t queueFamilyIndex, | |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::Bool32 supported; | |
| Result result = | |
| static_cast<Result>( d.vkGetPhysicalDeviceSurfaceSupportKHR( m_physicalDevice, | |
| queueFamilyIndex, | |
| static_cast<VkSurfaceKHR>( surface ), | |
| reinterpret_cast<VkBool32 *>( &supported ) ) ); | |
| return createResultValue( result, supported, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceSupportKHR" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| PhysicalDevice::getSurfaceCapabilitiesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, | |
| VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR * pSurfaceCapabilities, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilitiesKHR( | |
| m_physicalDevice, | |
| static_cast<VkSurfaceKHR>( surface ), | |
| reinterpret_cast<VkSurfaceCapabilitiesKHR *>( pSurfaceCapabilities ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR>::type | |
| PhysicalDevice::getSurfaceCapabilitiesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR surfaceCapabilities; | |
| Result result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilitiesKHR( | |
| m_physicalDevice, | |
| static_cast<VkSurfaceKHR>( surface ), | |
| reinterpret_cast<VkSurfaceCapabilitiesKHR *>( &surfaceCapabilities ) ) ); | |
| return createResultValue( | |
| result, surfaceCapabilities, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilitiesKHR" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| PhysicalDevice::getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, | |
| uint32_t * pSurfaceFormatCount, | |
| VULKAN_HPP_NAMESPACE::SurfaceFormatKHR * pSurfaceFormats, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkGetPhysicalDeviceSurfaceFormatsKHR( m_physicalDevice, | |
| static_cast<VkSurfaceKHR>( surface ), | |
| pSurfaceFormatCount, | |
| reinterpret_cast<VkSurfaceFormatKHR *>( pSurfaceFormats ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename SurfaceFormatKHRAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE | |
| typename ResultValueType<std::vector<SurfaceFormatKHR, SurfaceFormatKHRAllocator>>::type | |
| PhysicalDevice::getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<SurfaceFormatKHR, SurfaceFormatKHRAllocator> surfaceFormats; | |
| uint32_t surfaceFormatCount; | |
| Result result; | |
| do | |
| { | |
| result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormatsKHR( | |
| m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &surfaceFormatCount, nullptr ) ); | |
| if ( ( result == Result::eSuccess ) && surfaceFormatCount ) | |
| { | |
| surfaceFormats.resize( surfaceFormatCount ); | |
| result = static_cast<Result>( | |
| d.vkGetPhysicalDeviceSurfaceFormatsKHR( m_physicalDevice, | |
| static_cast<VkSurfaceKHR>( surface ), | |
| &surfaceFormatCount, | |
| reinterpret_cast<VkSurfaceFormatKHR *>( surfaceFormats.data() ) ) ); | |
| VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() ); | |
| } | |
| } while ( result == Result::eIncomplete ); | |
| if ( ( result == Result::eSuccess ) && ( surfaceFormatCount < surfaceFormats.size() ) ) | |
| { | |
| surfaceFormats.resize( surfaceFormatCount ); | |
| } | |
| return createResultValue( | |
| result, surfaceFormats, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceFormatsKHR" ); | |
| } | |
| template <typename SurfaceFormatKHRAllocator, | |
| typename Dispatch, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, SurfaceFormatKHR>::value, int>::type> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE | |
| typename ResultValueType<std::vector<SurfaceFormatKHR, SurfaceFormatKHRAllocator>>::type | |
| PhysicalDevice::getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, | |
| SurfaceFormatKHRAllocator & surfaceFormatKHRAllocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<SurfaceFormatKHR, SurfaceFormatKHRAllocator> surfaceFormats( surfaceFormatKHRAllocator ); | |
| uint32_t surfaceFormatCount; | |
| Result result; | |
| do | |
| { | |
| result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormatsKHR( | |
| m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &surfaceFormatCount, nullptr ) ); | |
| if ( ( result == Result::eSuccess ) && surfaceFormatCount ) | |
| { | |
| surfaceFormats.resize( surfaceFormatCount ); | |
| result = static_cast<Result>( | |
| d.vkGetPhysicalDeviceSurfaceFormatsKHR( m_physicalDevice, | |
| static_cast<VkSurfaceKHR>( surface ), | |
| &surfaceFormatCount, | |
| reinterpret_cast<VkSurfaceFormatKHR *>( surfaceFormats.data() ) ) ); | |
| VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() ); | |
| } | |
| } while ( result == Result::eIncomplete ); | |
| if ( ( result == Result::eSuccess ) && ( surfaceFormatCount < surfaceFormats.size() ) ) | |
| { | |
| surfaceFormats.resize( surfaceFormatCount ); | |
| } | |
| return createResultValue( | |
| result, surfaceFormats, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceFormatsKHR" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| PhysicalDevice::getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, | |
| uint32_t * pPresentModeCount, | |
| VULKAN_HPP_NAMESPACE::PresentModeKHR * pPresentModes, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkGetPhysicalDeviceSurfacePresentModesKHR( m_physicalDevice, | |
| static_cast<VkSurfaceKHR>( surface ), | |
| pPresentModeCount, | |
| reinterpret_cast<VkPresentModeKHR *>( pPresentModes ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename PresentModeKHRAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE | |
| typename ResultValueType<std::vector<PresentModeKHR, PresentModeKHRAllocator>>::type | |
| PhysicalDevice::getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<PresentModeKHR, PresentModeKHRAllocator> presentModes; | |
| uint32_t presentModeCount; | |
| Result result; | |
| do | |
| { | |
| result = static_cast<Result>( d.vkGetPhysicalDeviceSurfacePresentModesKHR( | |
| m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &presentModeCount, nullptr ) ); | |
| if ( ( result == Result::eSuccess ) && presentModeCount ) | |
| { | |
| presentModes.resize( presentModeCount ); | |
| result = static_cast<Result>( | |
| d.vkGetPhysicalDeviceSurfacePresentModesKHR( m_physicalDevice, | |
| static_cast<VkSurfaceKHR>( surface ), | |
| &presentModeCount, | |
| reinterpret_cast<VkPresentModeKHR *>( presentModes.data() ) ) ); | |
| VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() ); | |
| } | |
| } while ( result == Result::eIncomplete ); | |
| if ( ( result == Result::eSuccess ) && ( presentModeCount < presentModes.size() ) ) | |
| { | |
| presentModes.resize( presentModeCount ); | |
| } | |
| return createResultValue( | |
| result, presentModes, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfacePresentModesKHR" ); | |
| } | |
| template <typename PresentModeKHRAllocator, | |
| typename Dispatch, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, PresentModeKHR>::value, int>::type> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE | |
| typename ResultValueType<std::vector<PresentModeKHR, PresentModeKHRAllocator>>::type | |
| PhysicalDevice::getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, | |
| PresentModeKHRAllocator & presentModeKHRAllocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<PresentModeKHR, PresentModeKHRAllocator> presentModes( presentModeKHRAllocator ); | |
| uint32_t presentModeCount; | |
| Result result; | |
| do | |
| { | |
| result = static_cast<Result>( d.vkGetPhysicalDeviceSurfacePresentModesKHR( | |
| m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &presentModeCount, nullptr ) ); | |
| if ( ( result == Result::eSuccess ) && presentModeCount ) | |
| { | |
| presentModes.resize( presentModeCount ); | |
| result = static_cast<Result>( | |
| d.vkGetPhysicalDeviceSurfacePresentModesKHR( m_physicalDevice, | |
| static_cast<VkSurfaceKHR>( surface ), | |
| &presentModeCount, | |
| reinterpret_cast<VkPresentModeKHR *>( presentModes.data() ) ) ); | |
| VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() ); | |
| } | |
| } while ( result == Result::eIncomplete ); | |
| if ( ( result == Result::eSuccess ) && ( presentModeCount < presentModes.size() ) ) | |
| { | |
| presentModes.resize( presentModeCount ); | |
| } | |
| return createResultValue( | |
| result, presentModes, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfacePresentModesKHR" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_KHR_swapchain === | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::createSwapchainKHR( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR * pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| VULKAN_HPP_NAMESPACE::SwapchainKHR * pSwapchain, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkCreateSwapchainKHR( m_device, | |
| reinterpret_cast<const VkSwapchainCreateInfoKHR *>( pCreateInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), | |
| reinterpret_cast<VkSwapchainKHR *>( pSwapchain ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<VULKAN_HPP_NAMESPACE::SwapchainKHR>::type | |
| Device::createSwapchainKHR( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR & createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain; | |
| Result result = static_cast<Result>( | |
| d.vkCreateSwapchainKHR( m_device, | |
| reinterpret_cast<const VkSwapchainCreateInfoKHR *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkSwapchainKHR *>( &swapchain ) ) ); | |
| return createResultValue( result, swapchain, VULKAN_HPP_NAMESPACE_STRING "::Device::createSwapchainKHR" ); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>>::type | |
| Device::createSwapchainKHRUnique( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR & createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain; | |
| Result result = static_cast<Result>( | |
| d.vkCreateSwapchainKHR( m_device, | |
| reinterpret_cast<const VkSwapchainCreateInfoKHR *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkSwapchainKHR *>( &swapchain ) ) ); | |
| ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d ); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>( | |
| result, swapchain, VULKAN_HPP_NAMESPACE_STRING "::Device::createSwapchainKHRUnique", deleter ); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroySwapchainKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroySwapchainKHR( m_device, | |
| static_cast<VkSwapchainKHR>( swapchain ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| Device::destroySwapchainKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroySwapchainKHR( m_device, | |
| static_cast<VkSwapchainKHR>( swapchain ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroySwapchainKHR( m_device, | |
| static_cast<VkSwapchainKHR>( swapchain ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroySwapchainKHR( m_device, | |
| static_cast<VkSwapchainKHR>( swapchain ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::getSwapchainImagesKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, | |
| uint32_t * pSwapchainImageCount, | |
| VULKAN_HPP_NAMESPACE::Image * pSwapchainImages, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkGetSwapchainImagesKHR( m_device, | |
| static_cast<VkSwapchainKHR>( swapchain ), | |
| pSwapchainImageCount, | |
| reinterpret_cast<VkImage *>( pSwapchainImages ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename ImageAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<Image, ImageAllocator>>::type | |
| Device::getSwapchainImagesKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<Image, ImageAllocator> swapchainImages; | |
| uint32_t swapchainImageCount; | |
| Result result; | |
| do | |
| { | |
| result = static_cast<Result>( d.vkGetSwapchainImagesKHR( | |
| m_device, static_cast<VkSwapchainKHR>( swapchain ), &swapchainImageCount, nullptr ) ); | |
| if ( ( result == Result::eSuccess ) && swapchainImageCount ) | |
| { | |
| swapchainImages.resize( swapchainImageCount ); | |
| result = | |
| static_cast<Result>( d.vkGetSwapchainImagesKHR( m_device, | |
| static_cast<VkSwapchainKHR>( swapchain ), | |
| &swapchainImageCount, | |
| reinterpret_cast<VkImage *>( swapchainImages.data() ) ) ); | |
| VULKAN_HPP_ASSERT( swapchainImageCount <= swapchainImages.size() ); | |
| } | |
| } while ( result == Result::eIncomplete ); | |
| if ( ( result == Result::eSuccess ) && ( swapchainImageCount < swapchainImages.size() ) ) | |
| { | |
| swapchainImages.resize( swapchainImageCount ); | |
| } | |
| return createResultValue( result, swapchainImages, VULKAN_HPP_NAMESPACE_STRING "::Device::getSwapchainImagesKHR" ); | |
| } | |
| template <typename ImageAllocator, | |
| typename Dispatch, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, Image>::value, int>::type> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<Image, ImageAllocator>>::type | |
| Device::getSwapchainImagesKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, | |
| ImageAllocator & imageAllocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<Image, ImageAllocator> swapchainImages( imageAllocator ); | |
| uint32_t swapchainImageCount; | |
| Result result; | |
| do | |
| { | |
| result = static_cast<Result>( d.vkGetSwapchainImagesKHR( | |
| m_device, static_cast<VkSwapchainKHR>( swapchain ), &swapchainImageCount, nullptr ) ); | |
| if ( ( result == Result::eSuccess ) && swapchainImageCount ) | |
| { | |
| swapchainImages.resize( swapchainImageCount ); | |
| result = | |
| static_cast<Result>( d.vkGetSwapchainImagesKHR( m_device, | |
| static_cast<VkSwapchainKHR>( swapchain ), | |
| &swapchainImageCount, | |
| reinterpret_cast<VkImage *>( swapchainImages.data() ) ) ); | |
| VULKAN_HPP_ASSERT( swapchainImageCount <= swapchainImages.size() ); | |
| } | |
| } while ( result == Result::eIncomplete ); | |
| if ( ( result == Result::eSuccess ) && ( swapchainImageCount < swapchainImages.size() ) ) | |
| { | |
| swapchainImages.resize( swapchainImageCount ); | |
| } | |
| return createResultValue( result, swapchainImages, VULKAN_HPP_NAMESPACE_STRING "::Device::getSwapchainImagesKHR" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::acquireNextImageKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, | |
| uint64_t timeout, | |
| VULKAN_HPP_NAMESPACE::Semaphore semaphore, | |
| VULKAN_HPP_NAMESPACE::Fence fence, | |
| uint32_t * pImageIndex, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkAcquireNextImageKHR( m_device, | |
| static_cast<VkSwapchainKHR>( swapchain ), | |
| timeout, | |
| static_cast<VkSemaphore>( semaphore ), | |
| static_cast<VkFence>( fence ), | |
| pImageIndex ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<uint32_t> | |
| Device::acquireNextImageKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, | |
| uint64_t timeout, | |
| VULKAN_HPP_NAMESPACE::Semaphore semaphore, | |
| VULKAN_HPP_NAMESPACE::Fence fence, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| uint32_t imageIndex; | |
| Result result = static_cast<Result>( d.vkAcquireNextImageKHR( m_device, | |
| static_cast<VkSwapchainKHR>( swapchain ), | |
| timeout, | |
| static_cast<VkSemaphore>( semaphore ), | |
| static_cast<VkFence>( fence ), | |
| &imageIndex ) ); | |
| return createResultValue( result, | |
| imageIndex, | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::acquireNextImageKHR", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, | |
| VULKAN_HPP_NAMESPACE::Result::eTimeout, | |
| VULKAN_HPP_NAMESPACE::Result::eNotReady, | |
| VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR } ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Queue::presentKHR( | |
| const VULKAN_HPP_NAMESPACE::PresentInfoKHR * pPresentInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkQueuePresentKHR( m_queue, reinterpret_cast<const VkPresentInfoKHR *>( pPresentInfo ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Queue::presentKHR( const VULKAN_HPP_NAMESPACE::PresentInfoKHR & presentInfo, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| Result result = | |
| static_cast<Result>( d.vkQueuePresentKHR( m_queue, reinterpret_cast<const VkPresentInfoKHR *>( &presentInfo ) ) ); | |
| return createResultValue( | |
| result, | |
| VULKAN_HPP_NAMESPACE_STRING "::Queue::presentKHR", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR } ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getGroupPresentCapabilitiesKHR( | |
| VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR * pDeviceGroupPresentCapabilities, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkGetDeviceGroupPresentCapabilitiesKHR( | |
| m_device, reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHR *>( pDeviceGroupPresentCapabilities ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR>::type | |
| Device::getGroupPresentCapabilitiesKHR( Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR deviceGroupPresentCapabilities; | |
| Result result = static_cast<Result>( d.vkGetDeviceGroupPresentCapabilitiesKHR( | |
| m_device, reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHR *>( &deviceGroupPresentCapabilities ) ) ); | |
| return createResultValue( | |
| result, deviceGroupPresentCapabilities, VULKAN_HPP_NAMESPACE_STRING "::Device::getGroupPresentCapabilitiesKHR" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::getGroupSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, | |
| VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR * pModes, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkGetDeviceGroupSurfacePresentModesKHR( m_device, | |
| static_cast<VkSurfaceKHR>( surface ), | |
| reinterpret_cast<VkDeviceGroupPresentModeFlagsKHR *>( pModes ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR>::type | |
| Device::getGroupSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR modes; | |
| Result result = static_cast<Result>( | |
| d.vkGetDeviceGroupSurfacePresentModesKHR( m_device, | |
| static_cast<VkSurfaceKHR>( surface ), | |
| reinterpret_cast<VkDeviceGroupPresentModeFlagsKHR *>( &modes ) ) ); | |
| return createResultValue( result, modes, VULKAN_HPP_NAMESPACE_STRING "::Device::getGroupSurfacePresentModesKHR" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| PhysicalDevice::getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, | |
| uint32_t * pRectCount, | |
| VULKAN_HPP_NAMESPACE::Rect2D * pRects, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkGetPhysicalDevicePresentRectanglesKHR( | |
| m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), pRectCount, reinterpret_cast<VkRect2D *>( pRects ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Rect2DAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<Rect2D, Rect2DAllocator>>::type | |
| PhysicalDevice::getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<Rect2D, Rect2DAllocator> rects; | |
| uint32_t rectCount; | |
| Result result; | |
| do | |
| { | |
| result = static_cast<Result>( d.vkGetPhysicalDevicePresentRectanglesKHR( | |
| m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &rectCount, nullptr ) ); | |
| if ( ( result == Result::eSuccess ) && rectCount ) | |
| { | |
| rects.resize( rectCount ); | |
| result = static_cast<Result>( | |
| d.vkGetPhysicalDevicePresentRectanglesKHR( m_physicalDevice, | |
| static_cast<VkSurfaceKHR>( surface ), | |
| &rectCount, | |
| reinterpret_cast<VkRect2D *>( rects.data() ) ) ); | |
| VULKAN_HPP_ASSERT( rectCount <= rects.size() ); | |
| } | |
| } while ( result == Result::eIncomplete ); | |
| if ( ( result == Result::eSuccess ) && ( rectCount < rects.size() ) ) | |
| { | |
| rects.resize( rectCount ); | |
| } | |
| return createResultValue( result, rects, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getPresentRectanglesKHR" ); | |
| } | |
| template <typename Rect2DAllocator, | |
| typename Dispatch, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, Rect2D>::value, int>::type> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<Rect2D, Rect2DAllocator>>::type | |
| PhysicalDevice::getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, | |
| Rect2DAllocator & rect2DAllocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<Rect2D, Rect2DAllocator> rects( rect2DAllocator ); | |
| uint32_t rectCount; | |
| Result result; | |
| do | |
| { | |
| result = static_cast<Result>( d.vkGetPhysicalDevicePresentRectanglesKHR( | |
| m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &rectCount, nullptr ) ); | |
| if ( ( result == Result::eSuccess ) && rectCount ) | |
| { | |
| rects.resize( rectCount ); | |
| result = static_cast<Result>( | |
| d.vkGetPhysicalDevicePresentRectanglesKHR( m_physicalDevice, | |
| static_cast<VkSurfaceKHR>( surface ), | |
| &rectCount, | |
| reinterpret_cast<VkRect2D *>( rects.data() ) ) ); | |
| VULKAN_HPP_ASSERT( rectCount <= rects.size() ); | |
| } | |
| } while ( result == Result::eIncomplete ); | |
| if ( ( result == Result::eSuccess ) && ( rectCount < rects.size() ) ) | |
| { | |
| rects.resize( rectCount ); | |
| } | |
| return createResultValue( result, rects, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getPresentRectanglesKHR" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::acquireNextImage2KHR( const VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR * pAcquireInfo, | |
| uint32_t * pImageIndex, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkAcquireNextImage2KHR( | |
| m_device, reinterpret_cast<const VkAcquireNextImageInfoKHR *>( pAcquireInfo ), pImageIndex ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<uint32_t> | |
| Device::acquireNextImage2KHR( const VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR & acquireInfo, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| uint32_t imageIndex; | |
| Result result = static_cast<Result>( d.vkAcquireNextImage2KHR( | |
| m_device, reinterpret_cast<const VkAcquireNextImageInfoKHR *>( &acquireInfo ), &imageIndex ) ); | |
| return createResultValue( result, | |
| imageIndex, | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::acquireNextImage2KHR", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, | |
| VULKAN_HPP_NAMESPACE::Result::eTimeout, | |
| VULKAN_HPP_NAMESPACE::Result::eNotReady, | |
| VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR } ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_KHR_display === | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| PhysicalDevice::getDisplayPropertiesKHR( uint32_t * pPropertyCount, | |
| VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR * pProperties, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkGetPhysicalDeviceDisplayPropertiesKHR( | |
| m_physicalDevice, pPropertyCount, reinterpret_cast<VkDisplayPropertiesKHR *>( pProperties ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename DisplayPropertiesKHRAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE | |
| typename ResultValueType<std::vector<DisplayPropertiesKHR, DisplayPropertiesKHRAllocator>>::type | |
| PhysicalDevice::getDisplayPropertiesKHR( Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<DisplayPropertiesKHR, DisplayPropertiesKHRAllocator> properties; | |
| uint32_t propertyCount; | |
| Result result; | |
| do | |
| { | |
| result = | |
| static_cast<Result>( d.vkGetPhysicalDeviceDisplayPropertiesKHR( m_physicalDevice, &propertyCount, nullptr ) ); | |
| if ( ( result == Result::eSuccess ) && propertyCount ) | |
| { | |
| properties.resize( propertyCount ); | |
| result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPropertiesKHR( | |
| m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayPropertiesKHR *>( 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::getDisplayPropertiesKHR" ); | |
| } | |
| template <typename DisplayPropertiesKHRAllocator, | |
| typename Dispatch, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, DisplayPropertiesKHR>::value, int>::type> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE | |
| typename ResultValueType<std::vector<DisplayPropertiesKHR, DisplayPropertiesKHRAllocator>>::type | |
| PhysicalDevice::getDisplayPropertiesKHR( DisplayPropertiesKHRAllocator & displayPropertiesKHRAllocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<DisplayPropertiesKHR, DisplayPropertiesKHRAllocator> properties( displayPropertiesKHRAllocator ); | |
| uint32_t propertyCount; | |
| Result result; | |
| do | |
| { | |
| result = | |
| static_cast<Result>( d.vkGetPhysicalDeviceDisplayPropertiesKHR( m_physicalDevice, &propertyCount, nullptr ) ); | |
| if ( ( result == Result::eSuccess ) && propertyCount ) | |
| { | |
| properties.resize( propertyCount ); | |
| result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPropertiesKHR( | |
| m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayPropertiesKHR *>( 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::getDisplayPropertiesKHR" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| PhysicalDevice::getDisplayPlanePropertiesKHR( uint32_t * pPropertyCount, | |
| VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR * pProperties, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR( | |
| m_physicalDevice, pPropertyCount, reinterpret_cast<VkDisplayPlanePropertiesKHR *>( pProperties ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename DisplayPlanePropertiesKHRAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE | |
| typename ResultValueType<std::vector<DisplayPlanePropertiesKHR, DisplayPlanePropertiesKHRAllocator>>::type | |
| PhysicalDevice::getDisplayPlanePropertiesKHR( Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<DisplayPlanePropertiesKHR, DisplayPlanePropertiesKHRAllocator> properties; | |
| uint32_t propertyCount; | |
| Result result; | |
| do | |
| { | |
| result = static_cast<Result>( | |
| d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR( m_physicalDevice, &propertyCount, nullptr ) ); | |
| if ( ( result == Result::eSuccess ) && propertyCount ) | |
| { | |
| properties.resize( propertyCount ); | |
| result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR( | |
| m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayPlanePropertiesKHR *>( 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::getDisplayPlanePropertiesKHR" ); | |
| } | |
| template <typename DisplayPlanePropertiesKHRAllocator, | |
| typename Dispatch, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, DisplayPlanePropertiesKHR>::value, int>::type> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE | |
| typename ResultValueType<std::vector<DisplayPlanePropertiesKHR, DisplayPlanePropertiesKHRAllocator>>::type | |
| PhysicalDevice::getDisplayPlanePropertiesKHR( | |
| DisplayPlanePropertiesKHRAllocator & displayPlanePropertiesKHRAllocator, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<DisplayPlanePropertiesKHR, DisplayPlanePropertiesKHRAllocator> properties( | |
| displayPlanePropertiesKHRAllocator ); | |
| uint32_t propertyCount; | |
| Result result; | |
| do | |
| { | |
| result = static_cast<Result>( | |
| d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR( m_physicalDevice, &propertyCount, nullptr ) ); | |
| if ( ( result == Result::eSuccess ) && propertyCount ) | |
| { | |
| properties.resize( propertyCount ); | |
| result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR( | |
| m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayPlanePropertiesKHR *>( 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::getDisplayPlanePropertiesKHR" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, | |
| uint32_t * pDisplayCount, | |
| VULKAN_HPP_NAMESPACE::DisplayKHR * pDisplays, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkGetDisplayPlaneSupportedDisplaysKHR( | |
| m_physicalDevice, planeIndex, pDisplayCount, reinterpret_cast<VkDisplayKHR *>( pDisplays ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename DisplayKHRAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayKHR, DisplayKHRAllocator>>::type | |
| PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<DisplayKHR, DisplayKHRAllocator> displays; | |
| uint32_t displayCount; | |
| Result result; | |
| do | |
| { | |
| result = static_cast<Result>( | |
| d.vkGetDisplayPlaneSupportedDisplaysKHR( m_physicalDevice, planeIndex, &displayCount, nullptr ) ); | |
| if ( ( result == Result::eSuccess ) && displayCount ) | |
| { | |
| displays.resize( displayCount ); | |
| result = static_cast<Result>( d.vkGetDisplayPlaneSupportedDisplaysKHR( | |
| m_physicalDevice, planeIndex, &displayCount, reinterpret_cast<VkDisplayKHR *>( displays.data() ) ) ); | |
| VULKAN_HPP_ASSERT( displayCount <= displays.size() ); | |
| } | |
| } while ( result == Result::eIncomplete ); | |
| if ( ( result == Result::eSuccess ) && ( displayCount < displays.size() ) ) | |
| { | |
| displays.resize( displayCount ); | |
| } | |
| return createResultValue( | |
| result, displays, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR" ); | |
| } | |
| template <typename DisplayKHRAllocator, | |
| typename Dispatch, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, DisplayKHR>::value, int>::type> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayKHR, DisplayKHRAllocator>>::type | |
| PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, | |
| DisplayKHRAllocator & displayKHRAllocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<DisplayKHR, DisplayKHRAllocator> displays( displayKHRAllocator ); | |
| uint32_t displayCount; | |
| Result result; | |
| do | |
| { | |
| result = static_cast<Result>( | |
| d.vkGetDisplayPlaneSupportedDisplaysKHR( m_physicalDevice, planeIndex, &displayCount, nullptr ) ); | |
| if ( ( result == Result::eSuccess ) && displayCount ) | |
| { | |
| displays.resize( displayCount ); | |
| result = static_cast<Result>( d.vkGetDisplayPlaneSupportedDisplaysKHR( | |
| m_physicalDevice, planeIndex, &displayCount, reinterpret_cast<VkDisplayKHR *>( displays.data() ) ) ); | |
| VULKAN_HPP_ASSERT( displayCount <= displays.size() ); | |
| } | |
| } while ( result == Result::eIncomplete ); | |
| if ( ( result == Result::eSuccess ) && ( displayCount < displays.size() ) ) | |
| { | |
| displays.resize( displayCount ); | |
| } | |
| return createResultValue( | |
| result, displays, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| PhysicalDevice::getDisplayModePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, | |
| uint32_t * pPropertyCount, | |
| VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR * pProperties, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkGetDisplayModePropertiesKHR( m_physicalDevice, | |
| static_cast<VkDisplayKHR>( display ), | |
| pPropertyCount, | |
| reinterpret_cast<VkDisplayModePropertiesKHR *>( pProperties ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename DisplayModePropertiesKHRAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE | |
| typename ResultValueType<std::vector<DisplayModePropertiesKHR, DisplayModePropertiesKHRAllocator>>::type | |
| PhysicalDevice::getDisplayModePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<DisplayModePropertiesKHR, DisplayModePropertiesKHRAllocator> properties; | |
| uint32_t propertyCount; | |
| Result result; | |
| do | |
| { | |
| result = static_cast<Result>( d.vkGetDisplayModePropertiesKHR( | |
| m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, nullptr ) ); | |
| if ( ( result == Result::eSuccess ) && propertyCount ) | |
| { | |
| properties.resize( propertyCount ); | |
| result = static_cast<Result>( | |
| d.vkGetDisplayModePropertiesKHR( m_physicalDevice, | |
| static_cast<VkDisplayKHR>( display ), | |
| &propertyCount, | |
| reinterpret_cast<VkDisplayModePropertiesKHR *>( 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::getDisplayModePropertiesKHR" ); | |
| } | |
| template <typename DisplayModePropertiesKHRAllocator, | |
| typename Dispatch, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, DisplayModePropertiesKHR>::value, int>::type> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE | |
| typename ResultValueType<std::vector<DisplayModePropertiesKHR, DisplayModePropertiesKHRAllocator>>::type | |
| PhysicalDevice::getDisplayModePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, | |
| DisplayModePropertiesKHRAllocator & displayModePropertiesKHRAllocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<DisplayModePropertiesKHR, DisplayModePropertiesKHRAllocator> properties( | |
| displayModePropertiesKHRAllocator ); | |
| uint32_t propertyCount; | |
| Result result; | |
| do | |
| { | |
| result = static_cast<Result>( d.vkGetDisplayModePropertiesKHR( | |
| m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, nullptr ) ); | |
| if ( ( result == Result::eSuccess ) && propertyCount ) | |
| { | |
| properties.resize( propertyCount ); | |
| result = static_cast<Result>( | |
| d.vkGetDisplayModePropertiesKHR( m_physicalDevice, | |
| static_cast<VkDisplayKHR>( display ), | |
| &propertyCount, | |
| reinterpret_cast<VkDisplayModePropertiesKHR *>( 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::getDisplayModePropertiesKHR" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| PhysicalDevice::createDisplayModeKHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, | |
| const VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR * pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| VULKAN_HPP_NAMESPACE::DisplayModeKHR * pMode, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkCreateDisplayModeKHR( m_physicalDevice, | |
| static_cast<VkDisplayKHR>( display ), | |
| reinterpret_cast<const VkDisplayModeCreateInfoKHR *>( pCreateInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), | |
| reinterpret_cast<VkDisplayModeKHR *>( pMode ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayModeKHR>::type | |
| PhysicalDevice::createDisplayModeKHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, | |
| const VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR & createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::DisplayModeKHR mode; | |
| Result result = static_cast<Result>( | |
| d.vkCreateDisplayModeKHR( m_physicalDevice, | |
| static_cast<VkDisplayKHR>( display ), | |
| reinterpret_cast<const VkDisplayModeCreateInfoKHR *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkDisplayModeKHR *>( &mode ) ) ); | |
| return createResultValue( result, mode, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::createDisplayModeKHR" ); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayModeKHR, Dispatch>>::type | |
| PhysicalDevice::createDisplayModeKHRUnique( VULKAN_HPP_NAMESPACE::DisplayKHR display, | |
| const VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR & createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::DisplayModeKHR mode; | |
| Result result = static_cast<Result>( | |
| d.vkCreateDisplayModeKHR( m_physicalDevice, | |
| static_cast<VkDisplayKHR>( display ), | |
| reinterpret_cast<const VkDisplayModeCreateInfoKHR *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkDisplayModeKHR *>( &mode ) ) ); | |
| ObjectDestroy<PhysicalDevice, Dispatch> deleter( *this, allocator, d ); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::DisplayModeKHR, Dispatch>( | |
| result, mode, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::createDisplayModeKHRUnique", deleter ); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| PhysicalDevice::getDisplayPlaneCapabilitiesKHR( VULKAN_HPP_NAMESPACE::DisplayModeKHR mode, | |
| uint32_t planeIndex, | |
| VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR * pCapabilities, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkGetDisplayPlaneCapabilitiesKHR( m_physicalDevice, | |
| static_cast<VkDisplayModeKHR>( mode ), | |
| planeIndex, | |
| reinterpret_cast<VkDisplayPlaneCapabilitiesKHR *>( pCapabilities ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR>::type | |
| PhysicalDevice::getDisplayPlaneCapabilitiesKHR( VULKAN_HPP_NAMESPACE::DisplayModeKHR mode, | |
| uint32_t planeIndex, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR capabilities; | |
| Result result = static_cast<Result>( | |
| d.vkGetDisplayPlaneCapabilitiesKHR( m_physicalDevice, | |
| static_cast<VkDisplayModeKHR>( mode ), | |
| planeIndex, | |
| reinterpret_cast<VkDisplayPlaneCapabilitiesKHR *>( &capabilities ) ) ); | |
| return createResultValue( | |
| result, capabilities, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneCapabilitiesKHR" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Instance::createDisplayPlaneSurfaceKHR( const VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR * pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkCreateDisplayPlaneSurfaceKHR( m_instance, | |
| reinterpret_cast<const VkDisplaySurfaceCreateInfoKHR *>( pCreateInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), | |
| reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type | |
| Instance::createDisplayPlaneSurfaceKHR( const VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR & createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface; | |
| Result result = static_cast<Result>( | |
| d.vkCreateDisplayPlaneSurfaceKHR( m_instance, | |
| reinterpret_cast<const VkDisplaySurfaceCreateInfoKHR *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkSurfaceKHR *>( &surface ) ) ); | |
| return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDisplayPlaneSurfaceKHR" ); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type | |
| Instance::createDisplayPlaneSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR & createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface; | |
| Result result = static_cast<Result>( | |
| d.vkCreateDisplayPlaneSurfaceKHR( m_instance, | |
| reinterpret_cast<const VkDisplaySurfaceCreateInfoKHR *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkSurfaceKHR *>( &surface ) ) ); | |
| ObjectDestroy<Instance, Dispatch> deleter( *this, allocator, d ); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>( | |
| result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDisplayPlaneSurfaceKHRUnique", deleter ); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_KHR_display_swapchain === | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::createSharedSwapchainsKHR( uint32_t swapchainCount, | |
| const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR * pCreateInfos, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| VULKAN_HPP_NAMESPACE::SwapchainKHR * pSwapchains, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkCreateSharedSwapchainsKHR( m_device, | |
| swapchainCount, | |
| reinterpret_cast<const VkSwapchainCreateInfoKHR *>( pCreateInfos ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), | |
| reinterpret_cast<VkSwapchainKHR *>( pSwapchains ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename SwapchainKHRAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SwapchainKHR, SwapchainKHRAllocator>>::type | |
| Device::createSharedSwapchainsKHR( | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<VULKAN_HPP_NAMESPACE::SwapchainKHR, SwapchainKHRAllocator> swapchains( createInfos.size() ); | |
| Result result = static_cast<Result>( | |
| d.vkCreateSharedSwapchainsKHR( m_device, | |
| createInfos.size(), | |
| reinterpret_cast<const VkSwapchainCreateInfoKHR *>( createInfos.data() ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkSwapchainKHR *>( swapchains.data() ) ) ); | |
| return createResultValue( result, swapchains, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHR" ); | |
| } | |
| template <typename SwapchainKHRAllocator, | |
| typename Dispatch, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, SwapchainKHR>::value, int>::type> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SwapchainKHR, SwapchainKHRAllocator>>::type | |
| Device::createSharedSwapchainsKHR( | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| SwapchainKHRAllocator & swapchainKHRAllocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<VULKAN_HPP_NAMESPACE::SwapchainKHR, SwapchainKHRAllocator> swapchains( createInfos.size(), | |
| swapchainKHRAllocator ); | |
| Result result = static_cast<Result>( | |
| d.vkCreateSharedSwapchainsKHR( m_device, | |
| createInfos.size(), | |
| reinterpret_cast<const VkSwapchainCreateInfoKHR *>( createInfos.data() ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkSwapchainKHR *>( swapchains.data() ) ) ); | |
| return createResultValue( result, swapchains, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHR" ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<VULKAN_HPP_NAMESPACE::SwapchainKHR>::type | |
| Device::createSharedSwapchainKHR( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR & createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain; | |
| Result result = static_cast<Result>( | |
| d.vkCreateSharedSwapchainsKHR( m_device, | |
| 1, | |
| reinterpret_cast<const VkSwapchainCreateInfoKHR *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkSwapchainKHR *>( &swapchain ) ) ); | |
| return createResultValue( result, swapchain, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainKHR" ); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template <typename Dispatch, typename SwapchainKHRAllocator> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<std::vector<UniqueHandle<SwapchainKHR, Dispatch>, SwapchainKHRAllocator>>::type | |
| Device::createSharedSwapchainsKHRUnique( | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<UniqueHandle<SwapchainKHR, Dispatch>, SwapchainKHRAllocator> uniqueSwapchains; | |
| std::vector<SwapchainKHR> swapchains( createInfos.size() ); | |
| Result result = static_cast<Result>( | |
| d.vkCreateSharedSwapchainsKHR( m_device, | |
| createInfos.size(), | |
| reinterpret_cast<const VkSwapchainCreateInfoKHR *>( createInfos.data() ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkSwapchainKHR *>( swapchains.data() ) ) ); | |
| if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) | |
| { | |
| uniqueSwapchains.reserve( createInfos.size() ); | |
| ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d ); | |
| for ( size_t i = 0; i < createInfos.size(); i++ ) | |
| { | |
| uniqueSwapchains.push_back( UniqueHandle<SwapchainKHR, Dispatch>( swapchains[i], deleter ) ); | |
| } | |
| } | |
| return createResultValue( | |
| result, std::move( uniqueSwapchains ), VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHRUnique" ); | |
| } | |
| template <typename Dispatch, | |
| typename SwapchainKHRAllocator, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<SwapchainKHR, Dispatch>>::value, | |
| int>::type> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<std::vector<UniqueHandle<SwapchainKHR, Dispatch>, SwapchainKHRAllocator>>::type | |
| Device::createSharedSwapchainsKHRUnique( | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| SwapchainKHRAllocator & swapchainKHRAllocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<UniqueHandle<SwapchainKHR, Dispatch>, SwapchainKHRAllocator> uniqueSwapchains( swapchainKHRAllocator ); | |
| std::vector<SwapchainKHR> swapchains( createInfos.size() ); | |
| Result result = static_cast<Result>( | |
| d.vkCreateSharedSwapchainsKHR( m_device, | |
| createInfos.size(), | |
| reinterpret_cast<const VkSwapchainCreateInfoKHR *>( createInfos.data() ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkSwapchainKHR *>( swapchains.data() ) ) ); | |
| if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) | |
| { | |
| uniqueSwapchains.reserve( createInfos.size() ); | |
| ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d ); | |
| for ( size_t i = 0; i < createInfos.size(); i++ ) | |
| { | |
| uniqueSwapchains.push_back( UniqueHandle<SwapchainKHR, Dispatch>( swapchains[i], deleter ) ); | |
| } | |
| } | |
| return createResultValue( | |
| result, std::move( uniqueSwapchains ), VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHRUnique" ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<UniqueHandle<SwapchainKHR, Dispatch>>::type | |
| Device::createSharedSwapchainKHRUnique( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR & createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| SwapchainKHR swapchain; | |
| Result result = static_cast<Result>( | |
| d.vkCreateSharedSwapchainsKHR( m_device, | |
| 1, | |
| reinterpret_cast<const VkSwapchainCreateInfoKHR *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkSwapchainKHR *>( &swapchain ) ) ); | |
| ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d ); | |
| return createResultValue<SwapchainKHR, Dispatch>( | |
| result, swapchain, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainKHRUnique", deleter ); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #if defined( VK_USE_PLATFORM_XLIB_KHR ) | |
| //=== VK_KHR_xlib_surface === | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Instance::createXlibSurfaceKHR( const VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR * pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkCreateXlibSurfaceKHR( m_instance, | |
| reinterpret_cast<const VkXlibSurfaceCreateInfoKHR *>( pCreateInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), | |
| reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) ); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type | |
| Instance::createXlibSurfaceKHR( const VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR & createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface; | |
| Result result = static_cast<Result>( | |
| d.vkCreateXlibSurfaceKHR( m_instance, | |
| reinterpret_cast<const VkXlibSurfaceCreateInfoKHR *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkSurfaceKHR *>( &surface ) ) ); | |
| return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createXlibSurfaceKHR" ); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type | |
| Instance::createXlibSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR & createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface; | |
| Result result = static_cast<Result>( | |
| d.vkCreateXlibSurfaceKHR( m_instance, | |
| reinterpret_cast<const VkXlibSurfaceCreateInfoKHR *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkSurfaceKHR *>( &surface ) ) ); | |
| ObjectDestroy<Instance, Dispatch> deleter( *this, allocator, d ); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>( | |
| result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createXlibSurfaceKHRUnique", deleter ); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE Bool32 PhysicalDevice::getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, | |
| Display * dpy, | |
| VisualID visualID, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Bool32>( | |
| d.vkGetPhysicalDeviceXlibPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, dpy, visualID ) ); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE Bool32 PhysicalDevice::getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, | |
| Display & dpy, | |
| VisualID visualID, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return d.vkGetPhysicalDeviceXlibPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &dpy, visualID ); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #endif /*VK_USE_PLATFORM_XLIB_KHR*/ | |
| #if defined( VK_USE_PLATFORM_XCB_KHR ) | |
| //=== VK_KHR_xcb_surface === | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Instance::createXcbSurfaceKHR( const VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR * pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkCreateXcbSurfaceKHR( m_instance, | |
| reinterpret_cast<const VkXcbSurfaceCreateInfoKHR *>( pCreateInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), | |
| reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) ); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type | |
| Instance::createXcbSurfaceKHR( const VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR & createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface; | |
| Result result = static_cast<Result>( | |
| d.vkCreateXcbSurfaceKHR( m_instance, | |
| reinterpret_cast<const VkXcbSurfaceCreateInfoKHR *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkSurfaceKHR *>( &surface ) ) ); | |
| return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createXcbSurfaceKHR" ); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type | |
| Instance::createXcbSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR & createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface; | |
| Result result = static_cast<Result>( | |
| d.vkCreateXcbSurfaceKHR( m_instance, | |
| reinterpret_cast<const VkXcbSurfaceCreateInfoKHR *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkSurfaceKHR *>( &surface ) ) ); | |
| ObjectDestroy<Instance, Dispatch> deleter( *this, allocator, d ); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>( | |
| result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createXcbSurfaceKHRUnique", deleter ); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE Bool32 PhysicalDevice::getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, | |
| xcb_connection_t * connection, | |
| xcb_visualid_t visual_id, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Bool32>( | |
| d.vkGetPhysicalDeviceXcbPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, connection, visual_id ) ); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE Bool32 PhysicalDevice::getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, | |
| xcb_connection_t & connection, | |
| xcb_visualid_t visual_id, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return d.vkGetPhysicalDeviceXcbPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &connection, visual_id ); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #endif /*VK_USE_PLATFORM_XCB_KHR*/ | |
| #if defined( VK_USE_PLATFORM_WAYLAND_KHR ) | |
| //=== VK_KHR_wayland_surface === | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Instance::createWaylandSurfaceKHR( const VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR * pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkCreateWaylandSurfaceKHR( m_instance, | |
| reinterpret_cast<const VkWaylandSurfaceCreateInfoKHR *>( pCreateInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), | |
| reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) ); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type | |
| Instance::createWaylandSurfaceKHR( const VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR & createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface; | |
| Result result = static_cast<Result>( | |
| d.vkCreateWaylandSurfaceKHR( m_instance, | |
| reinterpret_cast<const VkWaylandSurfaceCreateInfoKHR *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkSurfaceKHR *>( &surface ) ) ); | |
| return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createWaylandSurfaceKHR" ); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type | |
| Instance::createWaylandSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR & createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface; | |
| Result result = static_cast<Result>( | |
| d.vkCreateWaylandSurfaceKHR( m_instance, | |
| reinterpret_cast<const VkWaylandSurfaceCreateInfoKHR *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkSurfaceKHR *>( &surface ) ) ); | |
| ObjectDestroy<Instance, Dispatch> deleter( *this, allocator, d ); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>( | |
| result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createWaylandSurfaceKHRUnique", deleter ); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE Bool32 PhysicalDevice::getWaylandPresentationSupportKHR( | |
| uint32_t queueFamilyIndex, struct wl_display * display, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Bool32>( | |
| d.vkGetPhysicalDeviceWaylandPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, display ) ); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE Bool32 PhysicalDevice::getWaylandPresentationSupportKHR( | |
| uint32_t queueFamilyIndex, struct wl_display & display, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return d.vkGetPhysicalDeviceWaylandPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &display ); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ | |
| #if defined( VK_USE_PLATFORM_ANDROID_KHR ) | |
| //=== VK_KHR_android_surface === | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Instance::createAndroidSurfaceKHR( const VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR * pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkCreateAndroidSurfaceKHR( m_instance, | |
| reinterpret_cast<const VkAndroidSurfaceCreateInfoKHR *>( pCreateInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), | |
| reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) ); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type | |
| Instance::createAndroidSurfaceKHR( const VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR & createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface; | |
| Result result = static_cast<Result>( | |
| d.vkCreateAndroidSurfaceKHR( m_instance, | |
| reinterpret_cast<const VkAndroidSurfaceCreateInfoKHR *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkSurfaceKHR *>( &surface ) ) ); | |
| return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createAndroidSurfaceKHR" ); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type | |
| Instance::createAndroidSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR & createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface; | |
| Result result = static_cast<Result>( | |
| d.vkCreateAndroidSurfaceKHR( m_instance, | |
| reinterpret_cast<const VkAndroidSurfaceCreateInfoKHR *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkSurfaceKHR *>( &surface ) ) ); | |
| ObjectDestroy<Instance, Dispatch> deleter( *this, allocator, d ); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>( | |
| result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createAndroidSurfaceKHRUnique", deleter ); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ | |
| #if defined( VK_USE_PLATFORM_WIN32_KHR ) | |
| //=== VK_KHR_win32_surface === | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Instance::createWin32SurfaceKHR( const VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR * pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkCreateWin32SurfaceKHR( m_instance, | |
| reinterpret_cast<const VkWin32SurfaceCreateInfoKHR *>( pCreateInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), | |
| reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) ); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type | |
| Instance::createWin32SurfaceKHR( const VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR & createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface; | |
| Result result = static_cast<Result>( | |
| d.vkCreateWin32SurfaceKHR( m_instance, | |
| reinterpret_cast<const VkWin32SurfaceCreateInfoKHR *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkSurfaceKHR *>( &surface ) ) ); | |
| return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createWin32SurfaceKHR" ); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type | |
| Instance::createWin32SurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR & createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface; | |
| Result result = static_cast<Result>( | |
| d.vkCreateWin32SurfaceKHR( m_instance, | |
| reinterpret_cast<const VkWin32SurfaceCreateInfoKHR *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkSurfaceKHR *>( &surface ) ) ); | |
| ObjectDestroy<Instance, Dispatch> deleter( *this, allocator, d ); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>( | |
| result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createWin32SurfaceKHRUnique", deleter ); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE Bool32 PhysicalDevice::getWin32PresentationSupportKHR( | |
| uint32_t queueFamilyIndex, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Bool32>( | |
| d.vkGetPhysicalDeviceWin32PresentationSupportKHR( m_physicalDevice, queueFamilyIndex ) ); | |
| } | |
| #endif /*VK_USE_PLATFORM_WIN32_KHR*/ | |
| //=== VK_EXT_debug_report === | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Instance::createDebugReportCallbackEXT( const VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT * pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT * pCallback, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkCreateDebugReportCallbackEXT( m_instance, | |
| reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT *>( pCreateInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), | |
| reinterpret_cast<VkDebugReportCallbackEXT *>( pCallback ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT>::type | |
| Instance::createDebugReportCallbackEXT( const VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT & createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback; | |
| Result result = static_cast<Result>( | |
| d.vkCreateDebugReportCallbackEXT( m_instance, | |
| reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkDebugReportCallbackEXT *>( &callback ) ) ); | |
| return createResultValue( | |
| result, callback, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDebugReportCallbackEXT" ); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT, Dispatch>>::type | |
| Instance::createDebugReportCallbackEXTUnique( | |
| const VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT & createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback; | |
| Result result = static_cast<Result>( | |
| d.vkCreateDebugReportCallbackEXT( m_instance, | |
| reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkDebugReportCallbackEXT *>( &callback ) ) ); | |
| ObjectDestroy<Instance, Dispatch> deleter( *this, allocator, d ); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT, Dispatch>( | |
| result, callback, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDebugReportCallbackEXTUnique", deleter ); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| Instance::destroyDebugReportCallbackEXT( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyDebugReportCallbackEXT( m_instance, | |
| static_cast<VkDebugReportCallbackEXT>( callback ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| Instance::destroyDebugReportCallbackEXT( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyDebugReportCallbackEXT( | |
| m_instance, | |
| static_cast<VkDebugReportCallbackEXT>( callback ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Instance::destroy( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyDebugReportCallbackEXT( m_instance, | |
| static_cast<VkDebugReportCallbackEXT>( callback ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Instance::destroy( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyDebugReportCallbackEXT( | |
| m_instance, | |
| static_cast<VkDebugReportCallbackEXT>( callback ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Instance::debugReportMessageEXT( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT flags, | |
| VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType, | |
| uint64_t object, | |
| size_t location, | |
| int32_t messageCode, | |
| const char * pLayerPrefix, | |
| const char * pMessage, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDebugReportMessageEXT( m_instance, | |
| static_cast<VkDebugReportFlagsEXT>( flags ), | |
| static_cast<VkDebugReportObjectTypeEXT>( objectType ), | |
| object, | |
| location, | |
| messageCode, | |
| pLayerPrefix, | |
| pMessage ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Instance::debugReportMessageEXT( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT flags, | |
| VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType, | |
| uint64_t object, | |
| size_t location, | |
| int32_t messageCode, | |
| const std::string & layerPrefix, | |
| const std::string & message, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDebugReportMessageEXT( m_instance, | |
| static_cast<VkDebugReportFlagsEXT>( flags ), | |
| static_cast<VkDebugReportObjectTypeEXT>( objectType ), | |
| object, | |
| location, | |
| messageCode, | |
| layerPrefix.c_str(), | |
| message.c_str() ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_EXT_debug_marker === | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::debugMarkerSetObjectTagEXT( | |
| const VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT * pTagInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkDebugMarkerSetObjectTagEXT( m_device, reinterpret_cast<const VkDebugMarkerObjectTagInfoEXT *>( pTagInfo ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| Device::debugMarkerSetObjectTagEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT & tagInfo, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| Result result = static_cast<Result>( | |
| d.vkDebugMarkerSetObjectTagEXT( m_device, reinterpret_cast<const VkDebugMarkerObjectTagInfoEXT *>( &tagInfo ) ) ); | |
| return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::debugMarkerSetObjectTagEXT" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::debugMarkerSetObjectNameEXT( | |
| const VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT * pNameInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkDebugMarkerSetObjectNameEXT( | |
| m_device, reinterpret_cast<const VkDebugMarkerObjectNameInfoEXT *>( pNameInfo ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| Device::debugMarkerSetObjectNameEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT & nameInfo, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| Result result = static_cast<Result>( d.vkDebugMarkerSetObjectNameEXT( | |
| m_device, reinterpret_cast<const VkDebugMarkerObjectNameInfoEXT *>( &nameInfo ) ) ); | |
| return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::debugMarkerSetObjectNameEXT" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::debugMarkerBeginEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT * pMarkerInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdDebugMarkerBeginEXT( m_commandBuffer, reinterpret_cast<const VkDebugMarkerMarkerInfoEXT *>( pMarkerInfo ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::debugMarkerBeginEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT & markerInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdDebugMarkerBeginEXT( m_commandBuffer, reinterpret_cast<const VkDebugMarkerMarkerInfoEXT *>( &markerInfo ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::debugMarkerEndEXT( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdDebugMarkerEndEXT( m_commandBuffer ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::debugMarkerInsertEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT * pMarkerInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdDebugMarkerInsertEXT( m_commandBuffer, reinterpret_cast<const VkDebugMarkerMarkerInfoEXT *>( pMarkerInfo ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::debugMarkerInsertEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT & markerInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdDebugMarkerInsertEXT( m_commandBuffer, reinterpret_cast<const VkDebugMarkerMarkerInfoEXT *>( &markerInfo ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #if defined( VK_ENABLE_BETA_EXTENSIONS ) | |
| //=== VK_KHR_video_queue === | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| PhysicalDevice::getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileKHR * pVideoProfile, | |
| VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR * pCapabilities, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkGetPhysicalDeviceVideoCapabilitiesKHR( m_physicalDevice, | |
| reinterpret_cast<const VkVideoProfileKHR *>( pVideoProfile ), | |
| reinterpret_cast<VkVideoCapabilitiesKHR *>( pCapabilities ) ) ); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR>::type | |
| PhysicalDevice::getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileKHR & videoProfile, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR capabilities; | |
| Result result = static_cast<Result>( | |
| d.vkGetPhysicalDeviceVideoCapabilitiesKHR( m_physicalDevice, | |
| reinterpret_cast<const VkVideoProfileKHR *>( &videoProfile ), | |
| reinterpret_cast<VkVideoCapabilitiesKHR *>( &capabilities ) ) ); | |
| return createResultValue( | |
| result, capabilities, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoCapabilitiesKHR" ); | |
| } | |
| template <typename X, typename Y, typename... Z, typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<StructureChain<X, Y, Z...>>::type | |
| PhysicalDevice::getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileKHR & videoProfile, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| StructureChain<X, Y, Z...> structureChain; | |
| VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR & capabilities = | |
| structureChain.template get<VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR>(); | |
| Result result = static_cast<Result>( | |
| d.vkGetPhysicalDeviceVideoCapabilitiesKHR( m_physicalDevice, | |
| reinterpret_cast<const VkVideoProfileKHR *>( &videoProfile ), | |
| reinterpret_cast<VkVideoCapabilitiesKHR *>( &capabilities ) ) ); | |
| return createResultValue( | |
| result, structureChain, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoCapabilitiesKHR" ); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getVideoFormatPropertiesKHR( | |
| const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR * pVideoFormatInfo, | |
| uint32_t * pVideoFormatPropertyCount, | |
| VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR * pVideoFormatProperties, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkGetPhysicalDeviceVideoFormatPropertiesKHR( | |
| m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceVideoFormatInfoKHR *>( pVideoFormatInfo ), | |
| pVideoFormatPropertyCount, | |
| reinterpret_cast<VkVideoFormatPropertiesKHR *>( pVideoFormatProperties ) ) ); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename VideoFormatPropertiesKHRAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE | |
| typename ResultValueType<std::vector<VideoFormatPropertiesKHR, VideoFormatPropertiesKHRAllocator>>::type | |
| PhysicalDevice::getVideoFormatPropertiesKHR( | |
| const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<VideoFormatPropertiesKHR, VideoFormatPropertiesKHRAllocator> videoFormatProperties; | |
| uint32_t videoFormatPropertyCount; | |
| Result result; | |
| do | |
| { | |
| result = static_cast<Result>( d.vkGetPhysicalDeviceVideoFormatPropertiesKHR( | |
| m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceVideoFormatInfoKHR *>( &videoFormatInfo ), | |
| &videoFormatPropertyCount, | |
| nullptr ) ); | |
| if ( ( result == Result::eSuccess ) && videoFormatPropertyCount ) | |
| { | |
| videoFormatProperties.resize( videoFormatPropertyCount ); | |
| result = static_cast<Result>( d.vkGetPhysicalDeviceVideoFormatPropertiesKHR( | |
| m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceVideoFormatInfoKHR *>( &videoFormatInfo ), | |
| &videoFormatPropertyCount, | |
| reinterpret_cast<VkVideoFormatPropertiesKHR *>( videoFormatProperties.data() ) ) ); | |
| VULKAN_HPP_ASSERT( videoFormatPropertyCount <= videoFormatProperties.size() ); | |
| } | |
| } while ( result == Result::eIncomplete ); | |
| if ( ( result == Result::eSuccess ) && ( videoFormatPropertyCount < videoFormatProperties.size() ) ) | |
| { | |
| videoFormatProperties.resize( videoFormatPropertyCount ); | |
| } | |
| return createResultValue( | |
| result, videoFormatProperties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoFormatPropertiesKHR" ); | |
| } | |
| template <typename VideoFormatPropertiesKHRAllocator, | |
| typename Dispatch, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, VideoFormatPropertiesKHR>::value, int>::type> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE | |
| typename ResultValueType<std::vector<VideoFormatPropertiesKHR, VideoFormatPropertiesKHRAllocator>>::type | |
| PhysicalDevice::getVideoFormatPropertiesKHR( | |
| const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo, | |
| VideoFormatPropertiesKHRAllocator & videoFormatPropertiesKHRAllocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<VideoFormatPropertiesKHR, VideoFormatPropertiesKHRAllocator> videoFormatProperties( | |
| videoFormatPropertiesKHRAllocator ); | |
| uint32_t videoFormatPropertyCount; | |
| Result result; | |
| do | |
| { | |
| result = static_cast<Result>( d.vkGetPhysicalDeviceVideoFormatPropertiesKHR( | |
| m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceVideoFormatInfoKHR *>( &videoFormatInfo ), | |
| &videoFormatPropertyCount, | |
| nullptr ) ); | |
| if ( ( result == Result::eSuccess ) && videoFormatPropertyCount ) | |
| { | |
| videoFormatProperties.resize( videoFormatPropertyCount ); | |
| result = static_cast<Result>( d.vkGetPhysicalDeviceVideoFormatPropertiesKHR( | |
| m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceVideoFormatInfoKHR *>( &videoFormatInfo ), | |
| &videoFormatPropertyCount, | |
| reinterpret_cast<VkVideoFormatPropertiesKHR *>( videoFormatProperties.data() ) ) ); | |
| VULKAN_HPP_ASSERT( videoFormatPropertyCount <= videoFormatProperties.size() ); | |
| } | |
| } while ( result == Result::eIncomplete ); | |
| if ( ( result == Result::eSuccess ) && ( videoFormatPropertyCount < videoFormatProperties.size() ) ) | |
| { | |
| videoFormatProperties.resize( videoFormatPropertyCount ); | |
| } | |
| return createResultValue( | |
| result, videoFormatProperties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoFormatPropertiesKHR" ); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::createVideoSessionKHR( const VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR * pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| VULKAN_HPP_NAMESPACE::VideoSessionKHR * pVideoSession, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkCreateVideoSessionKHR( m_device, | |
| reinterpret_cast<const VkVideoSessionCreateInfoKHR *>( pCreateInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), | |
| reinterpret_cast<VkVideoSessionKHR *>( pVideoSession ) ) ); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<VULKAN_HPP_NAMESPACE::VideoSessionKHR>::type | |
| Device::createVideoSessionKHR( const VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR & createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession; | |
| Result result = static_cast<Result>( | |
| d.vkCreateVideoSessionKHR( m_device, | |
| reinterpret_cast<const VkVideoSessionCreateInfoKHR *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkVideoSessionKHR *>( &videoSession ) ) ); | |
| return createResultValue( result, videoSession, VULKAN_HPP_NAMESPACE_STRING "::Device::createVideoSessionKHR" ); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::VideoSessionKHR, Dispatch>>::type | |
| Device::createVideoSessionKHRUnique( const VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR & createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession; | |
| Result result = static_cast<Result>( | |
| d.vkCreateVideoSessionKHR( m_device, | |
| reinterpret_cast<const VkVideoSessionCreateInfoKHR *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkVideoSessionKHR *>( &videoSession ) ) ); | |
| ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d ); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::VideoSessionKHR, Dispatch>( | |
| result, videoSession, VULKAN_HPP_NAMESPACE_STRING "::Device::createVideoSessionKHRUnique", deleter ); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroyVideoSessionKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyVideoSessionKHR( m_device, | |
| static_cast<VkVideoSessionKHR>( videoSession ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| Device::destroyVideoSessionKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyVideoSessionKHR( m_device, | |
| static_cast<VkVideoSessionKHR>( videoSession ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyVideoSessionKHR( m_device, | |
| static_cast<VkVideoSessionKHR>( videoSession ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyVideoSessionKHR( m_device, | |
| static_cast<VkVideoSessionKHR>( videoSession ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getVideoSessionMemoryRequirementsKHR( | |
| VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession, | |
| uint32_t * pVideoSessionMemoryRequirementsCount, | |
| VULKAN_HPP_NAMESPACE::VideoGetMemoryPropertiesKHR * pVideoSessionMemoryRequirements, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkGetVideoSessionMemoryRequirementsKHR( | |
| m_device, | |
| static_cast<VkVideoSessionKHR>( videoSession ), | |
| pVideoSessionMemoryRequirementsCount, | |
| reinterpret_cast<VkVideoGetMemoryPropertiesKHR *>( pVideoSessionMemoryRequirements ) ) ); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename VideoGetMemoryPropertiesKHRAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE | |
| typename ResultValueType<std::vector<VideoGetMemoryPropertiesKHR, VideoGetMemoryPropertiesKHRAllocator>>::type | |
| Device::getVideoSessionMemoryRequirementsKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<VideoGetMemoryPropertiesKHR, VideoGetMemoryPropertiesKHRAllocator> videoSessionMemoryRequirements; | |
| uint32_t videoSessionMemoryRequirementsCount; | |
| Result result; | |
| do | |
| { | |
| result = static_cast<Result>( d.vkGetVideoSessionMemoryRequirementsKHR( | |
| m_device, static_cast<VkVideoSessionKHR>( videoSession ), &videoSessionMemoryRequirementsCount, nullptr ) ); | |
| if ( ( result == Result::eSuccess ) && videoSessionMemoryRequirementsCount ) | |
| { | |
| videoSessionMemoryRequirements.resize( videoSessionMemoryRequirementsCount ); | |
| result = static_cast<Result>( d.vkGetVideoSessionMemoryRequirementsKHR( | |
| m_device, | |
| static_cast<VkVideoSessionKHR>( videoSession ), | |
| &videoSessionMemoryRequirementsCount, | |
| reinterpret_cast<VkVideoGetMemoryPropertiesKHR *>( videoSessionMemoryRequirements.data() ) ) ); | |
| VULKAN_HPP_ASSERT( videoSessionMemoryRequirementsCount <= videoSessionMemoryRequirements.size() ); | |
| } | |
| } while ( result == Result::eIncomplete ); | |
| if ( ( result == Result::eSuccess ) && | |
| ( videoSessionMemoryRequirementsCount < videoSessionMemoryRequirements.size() ) ) | |
| { | |
| videoSessionMemoryRequirements.resize( videoSessionMemoryRequirementsCount ); | |
| } | |
| return createResultValue( result, | |
| videoSessionMemoryRequirements, | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::getVideoSessionMemoryRequirementsKHR" ); | |
| } | |
| template < | |
| typename VideoGetMemoryPropertiesKHRAllocator, | |
| typename Dispatch, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, VideoGetMemoryPropertiesKHR>::value, int>::type> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE | |
| typename ResultValueType<std::vector<VideoGetMemoryPropertiesKHR, VideoGetMemoryPropertiesKHRAllocator>>::type | |
| Device::getVideoSessionMemoryRequirementsKHR( | |
| VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession, | |
| VideoGetMemoryPropertiesKHRAllocator & videoGetMemoryPropertiesKHRAllocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<VideoGetMemoryPropertiesKHR, VideoGetMemoryPropertiesKHRAllocator> videoSessionMemoryRequirements( | |
| videoGetMemoryPropertiesKHRAllocator ); | |
| uint32_t videoSessionMemoryRequirementsCount; | |
| Result result; | |
| do | |
| { | |
| result = static_cast<Result>( d.vkGetVideoSessionMemoryRequirementsKHR( | |
| m_device, static_cast<VkVideoSessionKHR>( videoSession ), &videoSessionMemoryRequirementsCount, nullptr ) ); | |
| if ( ( result == Result::eSuccess ) && videoSessionMemoryRequirementsCount ) | |
| { | |
| videoSessionMemoryRequirements.resize( videoSessionMemoryRequirementsCount ); | |
| result = static_cast<Result>( d.vkGetVideoSessionMemoryRequirementsKHR( | |
| m_device, | |
| static_cast<VkVideoSessionKHR>( videoSession ), | |
| &videoSessionMemoryRequirementsCount, | |
| reinterpret_cast<VkVideoGetMemoryPropertiesKHR *>( videoSessionMemoryRequirements.data() ) ) ); | |
| VULKAN_HPP_ASSERT( videoSessionMemoryRequirementsCount <= videoSessionMemoryRequirements.size() ); | |
| } | |
| } while ( result == Result::eIncomplete ); | |
| if ( ( result == Result::eSuccess ) && | |
| ( videoSessionMemoryRequirementsCount < videoSessionMemoryRequirements.size() ) ) | |
| { | |
| videoSessionMemoryRequirements.resize( videoSessionMemoryRequirementsCount ); | |
| } | |
| return createResultValue( result, | |
| videoSessionMemoryRequirements, | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::getVideoSessionMemoryRequirementsKHR" ); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::bindVideoSessionMemoryKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession, | |
| uint32_t videoSessionBindMemoryCount, | |
| const VULKAN_HPP_NAMESPACE::VideoBindMemoryKHR * pVideoSessionBindMemories, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkBindVideoSessionMemoryKHR( m_device, | |
| static_cast<VkVideoSessionKHR>( videoSession ), | |
| videoSessionBindMemoryCount, | |
| reinterpret_cast<const VkVideoBindMemoryKHR *>( pVideoSessionBindMemories ) ) ); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| Device::bindVideoSessionMemoryKHR( | |
| VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::VideoBindMemoryKHR> const & videoSessionBindMemories, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| Result result = static_cast<Result>( d.vkBindVideoSessionMemoryKHR( | |
| m_device, | |
| static_cast<VkVideoSessionKHR>( videoSession ), | |
| videoSessionBindMemories.size(), | |
| reinterpret_cast<const VkVideoBindMemoryKHR *>( videoSessionBindMemories.data() ) ) ); | |
| return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindVideoSessionMemoryKHR" ); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createVideoSessionParametersKHR( | |
| const VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR * pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR * pVideoSessionParameters, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkCreateVideoSessionParametersKHR( | |
| m_device, | |
| reinterpret_cast<const VkVideoSessionParametersCreateInfoKHR *>( pCreateInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), | |
| reinterpret_cast<VkVideoSessionParametersKHR *>( pVideoSessionParameters ) ) ); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR>::type | |
| Device::createVideoSessionParametersKHR( | |
| const VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR & createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters; | |
| Result result = static_cast<Result>( d.vkCreateVideoSessionParametersKHR( | |
| m_device, | |
| reinterpret_cast<const VkVideoSessionParametersCreateInfoKHR *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkVideoSessionParametersKHR *>( &videoSessionParameters ) ) ); | |
| return createResultValue( | |
| result, videoSessionParameters, VULKAN_HPP_NAMESPACE_STRING "::Device::createVideoSessionParametersKHR" ); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR, Dispatch>>::type | |
| Device::createVideoSessionParametersKHRUnique( | |
| const VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR & createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters; | |
| Result result = static_cast<Result>( d.vkCreateVideoSessionParametersKHR( | |
| m_device, | |
| reinterpret_cast<const VkVideoSessionParametersCreateInfoKHR *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkVideoSessionParametersKHR *>( &videoSessionParameters ) ) ); | |
| ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d ); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR, Dispatch>( | |
| result, | |
| videoSessionParameters, | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createVideoSessionParametersKHRUnique", | |
| deleter ); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::updateVideoSessionParametersKHR( | |
| VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters, | |
| const VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR * pUpdateInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkUpdateVideoSessionParametersKHR( | |
| m_device, | |
| static_cast<VkVideoSessionParametersKHR>( videoSessionParameters ), | |
| reinterpret_cast<const VkVideoSessionParametersUpdateInfoKHR *>( pUpdateInfo ) ) ); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| Device::updateVideoSessionParametersKHR( | |
| VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters, | |
| const VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR & updateInfo, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| Result result = static_cast<Result>( d.vkUpdateVideoSessionParametersKHR( | |
| m_device, | |
| static_cast<VkVideoSessionParametersKHR>( videoSessionParameters ), | |
| reinterpret_cast<const VkVideoSessionParametersUpdateInfoKHR *>( &updateInfo ) ) ); | |
| return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::updateVideoSessionParametersKHR" ); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| Device::destroyVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyVideoSessionParametersKHR( m_device, | |
| static_cast<VkVideoSessionParametersKHR>( videoSessionParameters ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| Device::destroyVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyVideoSessionParametersKHR( | |
| m_device, | |
| static_cast<VkVideoSessionParametersKHR>( videoSessionParameters ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyVideoSessionParametersKHR( m_device, | |
| static_cast<VkVideoSessionParametersKHR>( videoSessionParameters ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyVideoSessionParametersKHR( | |
| m_device, | |
| static_cast<VkVideoSessionParametersKHR>( videoSessionParameters ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::beginVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR * pBeginInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdBeginVideoCodingKHR( m_commandBuffer, reinterpret_cast<const VkVideoBeginCodingInfoKHR *>( pBeginInfo ) ); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::beginVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR & beginInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdBeginVideoCodingKHR( m_commandBuffer, reinterpret_cast<const VkVideoBeginCodingInfoKHR *>( &beginInfo ) ); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::endVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR * pEndCodingInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdEndVideoCodingKHR( m_commandBuffer, reinterpret_cast<const VkVideoEndCodingInfoKHR *>( pEndCodingInfo ) ); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::endVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR & endCodingInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdEndVideoCodingKHR( m_commandBuffer, reinterpret_cast<const VkVideoEndCodingInfoKHR *>( &endCodingInfo ) ); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::controlVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR * pCodingControlInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdControlVideoCodingKHR( m_commandBuffer, | |
| reinterpret_cast<const VkVideoCodingControlInfoKHR *>( pCodingControlInfo ) ); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::controlVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR & codingControlInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdControlVideoCodingKHR( m_commandBuffer, | |
| reinterpret_cast<const VkVideoCodingControlInfoKHR *>( &codingControlInfo ) ); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #endif /*VK_ENABLE_BETA_EXTENSIONS*/ | |
| #if defined( VK_ENABLE_BETA_EXTENSIONS ) | |
| //=== VK_KHR_video_decode_queue === | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::decodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR * pFrameInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdDecodeVideoKHR( m_commandBuffer, reinterpret_cast<const VkVideoDecodeInfoKHR *>( pFrameInfo ) ); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::decodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR & frameInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdDecodeVideoKHR( m_commandBuffer, reinterpret_cast<const VkVideoDecodeInfoKHR *>( &frameInfo ) ); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #endif /*VK_ENABLE_BETA_EXTENSIONS*/ | |
| //=== VK_EXT_transform_feedback === | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::bindTransformFeedbackBuffersEXT( uint32_t firstBinding, | |
| uint32_t bindingCount, | |
| const VULKAN_HPP_NAMESPACE::Buffer * pBuffers, | |
| const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets, | |
| const VULKAN_HPP_NAMESPACE::DeviceSize * pSizes, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdBindTransformFeedbackBuffersEXT( m_commandBuffer, | |
| firstBinding, | |
| bindingCount, | |
| reinterpret_cast<const VkBuffer *>( pBuffers ), | |
| reinterpret_cast<const VkDeviceSize *>( pOffsets ), | |
| reinterpret_cast<const VkDeviceSize *>( pSizes ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::bindTransformFeedbackBuffersEXT( uint32_t firstBinding, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| # ifdef VULKAN_HPP_NO_EXCEPTIONS | |
| VULKAN_HPP_ASSERT( buffers.size() == offsets.size() ); | |
| VULKAN_HPP_ASSERT( sizes.empty() || buffers.size() == sizes.size() ); | |
| # else | |
| if ( buffers.size() != offsets.size() ) | |
| { | |
| throw LogicError( VULKAN_HPP_NAMESPACE_STRING | |
| "::CommandBuffer::bindTransformFeedbackBuffersEXT: buffers.size() != offsets.size()" ); | |
| } | |
| if ( !sizes.empty() && buffers.size() != sizes.size() ) | |
| { | |
| throw LogicError( VULKAN_HPP_NAMESPACE_STRING | |
| "::CommandBuffer::bindTransformFeedbackBuffersEXT: buffers.size() != sizes.size()" ); | |
| } | |
| # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ | |
| d.vkCmdBindTransformFeedbackBuffersEXT( m_commandBuffer, | |
| firstBinding, | |
| buffers.size(), | |
| reinterpret_cast<const VkBuffer *>( buffers.data() ), | |
| reinterpret_cast<const VkDeviceSize *>( offsets.data() ), | |
| reinterpret_cast<const VkDeviceSize *>( sizes.data() ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::beginTransformFeedbackEXT( uint32_t firstCounterBuffer, | |
| uint32_t counterBufferCount, | |
| const VULKAN_HPP_NAMESPACE::Buffer * pCounterBuffers, | |
| const VULKAN_HPP_NAMESPACE::DeviceSize * pCounterBufferOffsets, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdBeginTransformFeedbackEXT( m_commandBuffer, | |
| firstCounterBuffer, | |
| counterBufferCount, | |
| reinterpret_cast<const VkBuffer *>( pCounterBuffers ), | |
| reinterpret_cast<const VkDeviceSize *>( pCounterBufferOffsets ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::beginTransformFeedbackEXT( | |
| uint32_t firstCounterBuffer, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & counterBuffers, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| # ifdef VULKAN_HPP_NO_EXCEPTIONS | |
| VULKAN_HPP_ASSERT( counterBufferOffsets.empty() || counterBuffers.size() == counterBufferOffsets.size() ); | |
| # else | |
| if ( !counterBufferOffsets.empty() && counterBuffers.size() != counterBufferOffsets.size() ) | |
| { | |
| throw LogicError( | |
| VULKAN_HPP_NAMESPACE_STRING | |
| "::CommandBuffer::beginTransformFeedbackEXT: counterBuffers.size() != counterBufferOffsets.size()" ); | |
| } | |
| # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ | |
| d.vkCmdBeginTransformFeedbackEXT( m_commandBuffer, | |
| firstCounterBuffer, | |
| counterBuffers.size(), | |
| reinterpret_cast<const VkBuffer *>( counterBuffers.data() ), | |
| reinterpret_cast<const VkDeviceSize *>( counterBufferOffsets.data() ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::endTransformFeedbackEXT( uint32_t firstCounterBuffer, | |
| uint32_t counterBufferCount, | |
| const VULKAN_HPP_NAMESPACE::Buffer * pCounterBuffers, | |
| const VULKAN_HPP_NAMESPACE::DeviceSize * pCounterBufferOffsets, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdEndTransformFeedbackEXT( m_commandBuffer, | |
| firstCounterBuffer, | |
| counterBufferCount, | |
| reinterpret_cast<const VkBuffer *>( pCounterBuffers ), | |
| reinterpret_cast<const VkDeviceSize *>( pCounterBufferOffsets ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::endTransformFeedbackEXT( | |
| uint32_t firstCounterBuffer, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & counterBuffers, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| # ifdef VULKAN_HPP_NO_EXCEPTIONS | |
| VULKAN_HPP_ASSERT( counterBufferOffsets.empty() || counterBuffers.size() == counterBufferOffsets.size() ); | |
| # else | |
| if ( !counterBufferOffsets.empty() && counterBuffers.size() != counterBufferOffsets.size() ) | |
| { | |
| throw LogicError( | |
| VULKAN_HPP_NAMESPACE_STRING | |
| "::CommandBuffer::endTransformFeedbackEXT: counterBuffers.size() != counterBufferOffsets.size()" ); | |
| } | |
| # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ | |
| d.vkCmdEndTransformFeedbackEXT( m_commandBuffer, | |
| firstCounterBuffer, | |
| counterBuffers.size(), | |
| reinterpret_cast<const VkBuffer *>( counterBuffers.data() ), | |
| reinterpret_cast<const VkDeviceSize *>( counterBufferOffsets.data() ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::beginQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool, | |
| uint32_t query, | |
| VULKAN_HPP_NAMESPACE::QueryControlFlags flags, | |
| uint32_t index, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdBeginQueryIndexedEXT( | |
| m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query, static_cast<VkQueryControlFlags>( flags ), index ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::endQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool, | |
| uint32_t query, | |
| uint32_t index, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdEndQueryIndexedEXT( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query, index ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::drawIndirectByteCountEXT( uint32_t instanceCount, | |
| uint32_t firstInstance, | |
| VULKAN_HPP_NAMESPACE::Buffer counterBuffer, | |
| VULKAN_HPP_NAMESPACE::DeviceSize counterBufferOffset, | |
| uint32_t counterOffset, | |
| uint32_t vertexStride, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdDrawIndirectByteCountEXT( m_commandBuffer, | |
| instanceCount, | |
| firstInstance, | |
| static_cast<VkBuffer>( counterBuffer ), | |
| static_cast<VkDeviceSize>( counterBufferOffset ), | |
| counterOffset, | |
| vertexStride ); | |
| } | |
| //=== VK_NVX_binary_import === | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::createCuModuleNVX( const VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX * pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| VULKAN_HPP_NAMESPACE::CuModuleNVX * pModule, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkCreateCuModuleNVX( m_device, | |
| reinterpret_cast<const VkCuModuleCreateInfoNVX *>( pCreateInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), | |
| reinterpret_cast<VkCuModuleNVX *>( pModule ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<VULKAN_HPP_NAMESPACE::CuModuleNVX>::type | |
| Device::createCuModuleNVX( const VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX & createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::CuModuleNVX module; | |
| Result result = static_cast<Result>( | |
| d.vkCreateCuModuleNVX( m_device, | |
| reinterpret_cast<const VkCuModuleCreateInfoNVX *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkCuModuleNVX *>( &module ) ) ); | |
| return createResultValue( result, module, VULKAN_HPP_NAMESPACE_STRING "::Device::createCuModuleNVX" ); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CuModuleNVX, Dispatch>>::type | |
| Device::createCuModuleNVXUnique( const VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX & createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::CuModuleNVX module; | |
| Result result = static_cast<Result>( | |
| d.vkCreateCuModuleNVX( m_device, | |
| reinterpret_cast<const VkCuModuleCreateInfoNVX *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkCuModuleNVX *>( &module ) ) ); | |
| ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d ); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::CuModuleNVX, Dispatch>( | |
| result, module, VULKAN_HPP_NAMESPACE_STRING "::Device::createCuModuleNVXUnique", deleter ); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::createCuFunctionNVX( const VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX * pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| VULKAN_HPP_NAMESPACE::CuFunctionNVX * pFunction, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkCreateCuFunctionNVX( m_device, | |
| reinterpret_cast<const VkCuFunctionCreateInfoNVX *>( pCreateInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), | |
| reinterpret_cast<VkCuFunctionNVX *>( pFunction ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<VULKAN_HPP_NAMESPACE::CuFunctionNVX>::type | |
| Device::createCuFunctionNVX( const VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX & createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::CuFunctionNVX function; | |
| Result result = static_cast<Result>( | |
| d.vkCreateCuFunctionNVX( m_device, | |
| reinterpret_cast<const VkCuFunctionCreateInfoNVX *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkCuFunctionNVX *>( &function ) ) ); | |
| return createResultValue( result, function, VULKAN_HPP_NAMESPACE_STRING "::Device::createCuFunctionNVX" ); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CuFunctionNVX, Dispatch>>::type | |
| Device::createCuFunctionNVXUnique( const VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX & createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::CuFunctionNVX function; | |
| Result result = static_cast<Result>( | |
| d.vkCreateCuFunctionNVX( m_device, | |
| reinterpret_cast<const VkCuFunctionCreateInfoNVX *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkCuFunctionNVX *>( &function ) ) ); | |
| ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d ); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::CuFunctionNVX, Dispatch>( | |
| result, function, VULKAN_HPP_NAMESPACE_STRING "::Device::createCuFunctionNVXUnique", deleter ); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroyCuModuleNVX( VULKAN_HPP_NAMESPACE::CuModuleNVX module, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyCuModuleNVX( | |
| m_device, static_cast<VkCuModuleNVX>( module ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| Device::destroyCuModuleNVX( VULKAN_HPP_NAMESPACE::CuModuleNVX module, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyCuModuleNVX( m_device, | |
| static_cast<VkCuModuleNVX>( module ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::CuModuleNVX module, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyCuModuleNVX( | |
| m_device, static_cast<VkCuModuleNVX>( module ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::CuModuleNVX module, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyCuModuleNVX( m_device, | |
| static_cast<VkCuModuleNVX>( module ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroyCuFunctionNVX( VULKAN_HPP_NAMESPACE::CuFunctionNVX function, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyCuFunctionNVX( m_device, | |
| static_cast<VkCuFunctionNVX>( function ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| Device::destroyCuFunctionNVX( VULKAN_HPP_NAMESPACE::CuFunctionNVX function, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyCuFunctionNVX( m_device, | |
| static_cast<VkCuFunctionNVX>( function ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::CuFunctionNVX function, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyCuFunctionNVX( m_device, | |
| static_cast<VkCuFunctionNVX>( function ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::CuFunctionNVX function, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyCuFunctionNVX( m_device, | |
| static_cast<VkCuFunctionNVX>( function ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::cuLaunchKernelNVX( const VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX * pLaunchInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdCuLaunchKernelNVX( m_commandBuffer, reinterpret_cast<const VkCuLaunchInfoNVX *>( pLaunchInfo ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::cuLaunchKernelNVX( const VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX & launchInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdCuLaunchKernelNVX( m_commandBuffer, reinterpret_cast<const VkCuLaunchInfoNVX *>( &launchInfo ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_NVX_image_view_handle === | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE uint32_t Device::getImageViewHandleNVX( const VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX * pInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return d.vkGetImageViewHandleNVX( m_device, reinterpret_cast<const VkImageViewHandleInfoNVX *>( pInfo ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE uint32_t Device::getImageViewHandleNVX( const VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX & info, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return d.vkGetImageViewHandleNVX( m_device, reinterpret_cast<const VkImageViewHandleInfoNVX *>( &info ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::getImageViewAddressNVX( VULKAN_HPP_NAMESPACE::ImageView imageView, | |
| VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX * pProperties, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkGetImageViewAddressNVX( m_device, | |
| static_cast<VkImageView>( imageView ), | |
| reinterpret_cast<VkImageViewAddressPropertiesNVX *>( pProperties ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX>::type | |
| Device::getImageViewAddressNVX( VULKAN_HPP_NAMESPACE::ImageView imageView, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX properties; | |
| Result result = static_cast<Result>( | |
| d.vkGetImageViewAddressNVX( m_device, | |
| static_cast<VkImageView>( imageView ), | |
| reinterpret_cast<VkImageViewAddressPropertiesNVX *>( &properties ) ) ); | |
| return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING "::Device::getImageViewAddressNVX" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_AMD_draw_indirect_count === | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer buffer, | |
| VULKAN_HPP_NAMESPACE::DeviceSize offset, | |
| VULKAN_HPP_NAMESPACE::Buffer countBuffer, | |
| VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, | |
| uint32_t maxDrawCount, | |
| uint32_t stride, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdDrawIndirectCountAMD( m_commandBuffer, | |
| static_cast<VkBuffer>( buffer ), | |
| static_cast<VkDeviceSize>( offset ), | |
| static_cast<VkBuffer>( countBuffer ), | |
| static_cast<VkDeviceSize>( countBufferOffset ), | |
| maxDrawCount, | |
| stride ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer buffer, | |
| VULKAN_HPP_NAMESPACE::DeviceSize offset, | |
| VULKAN_HPP_NAMESPACE::Buffer countBuffer, | |
| VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, | |
| uint32_t maxDrawCount, | |
| uint32_t stride, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdDrawIndexedIndirectCountAMD( m_commandBuffer, | |
| static_cast<VkBuffer>( buffer ), | |
| static_cast<VkDeviceSize>( offset ), | |
| static_cast<VkBuffer>( countBuffer ), | |
| static_cast<VkDeviceSize>( countBufferOffset ), | |
| maxDrawCount, | |
| stride ); | |
| } | |
| //=== VK_AMD_shader_info === | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::getShaderInfoAMD( VULKAN_HPP_NAMESPACE::Pipeline pipeline, | |
| VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage, | |
| VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD infoType, | |
| size_t * pInfoSize, | |
| void * pInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkGetShaderInfoAMD( m_device, | |
| static_cast<VkPipeline>( pipeline ), | |
| static_cast<VkShaderStageFlagBits>( shaderStage ), | |
| static_cast<VkShaderInfoTypeAMD>( infoType ), | |
| pInfoSize, | |
| pInfo ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Uint8_tAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type | |
| Device::getShaderInfoAMD( VULKAN_HPP_NAMESPACE::Pipeline pipeline, | |
| VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage, | |
| VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD infoType, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<uint8_t, Uint8_tAllocator> info; | |
| size_t infoSize; | |
| Result result; | |
| do | |
| { | |
| result = static_cast<Result>( d.vkGetShaderInfoAMD( m_device, | |
| static_cast<VkPipeline>( pipeline ), | |
| static_cast<VkShaderStageFlagBits>( shaderStage ), | |
| static_cast<VkShaderInfoTypeAMD>( infoType ), | |
| &infoSize, | |
| nullptr ) ); | |
| if ( ( result == Result::eSuccess ) && infoSize ) | |
| { | |
| info.resize( infoSize ); | |
| result = static_cast<Result>( d.vkGetShaderInfoAMD( m_device, | |
| static_cast<VkPipeline>( pipeline ), | |
| static_cast<VkShaderStageFlagBits>( shaderStage ), | |
| static_cast<VkShaderInfoTypeAMD>( infoType ), | |
| &infoSize, | |
| reinterpret_cast<void *>( info.data() ) ) ); | |
| VULKAN_HPP_ASSERT( infoSize <= info.size() ); | |
| } | |
| } while ( result == Result::eIncomplete ); | |
| if ( ( result == Result::eSuccess ) && ( infoSize < info.size() ) ) | |
| { | |
| info.resize( infoSize ); | |
| } | |
| return createResultValue( result, info, VULKAN_HPP_NAMESPACE_STRING "::Device::getShaderInfoAMD" ); | |
| } | |
| template <typename Uint8_tAllocator, | |
| typename Dispatch, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, uint8_t>::value, int>::type> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type | |
| Device::getShaderInfoAMD( VULKAN_HPP_NAMESPACE::Pipeline pipeline, | |
| VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage, | |
| VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD infoType, | |
| Uint8_tAllocator & uint8_tAllocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<uint8_t, Uint8_tAllocator> info( uint8_tAllocator ); | |
| size_t infoSize; | |
| Result result; | |
| do | |
| { | |
| result = static_cast<Result>( d.vkGetShaderInfoAMD( m_device, | |
| static_cast<VkPipeline>( pipeline ), | |
| static_cast<VkShaderStageFlagBits>( shaderStage ), | |
| static_cast<VkShaderInfoTypeAMD>( infoType ), | |
| &infoSize, | |
| nullptr ) ); | |
| if ( ( result == Result::eSuccess ) && infoSize ) | |
| { | |
| info.resize( infoSize ); | |
| result = static_cast<Result>( d.vkGetShaderInfoAMD( m_device, | |
| static_cast<VkPipeline>( pipeline ), | |
| static_cast<VkShaderStageFlagBits>( shaderStage ), | |
| static_cast<VkShaderInfoTypeAMD>( infoType ), | |
| &infoSize, | |
| reinterpret_cast<void *>( info.data() ) ) ); | |
| VULKAN_HPP_ASSERT( infoSize <= info.size() ); | |
| } | |
| } while ( result == Result::eIncomplete ); | |
| if ( ( result == Result::eSuccess ) && ( infoSize < info.size() ) ) | |
| { | |
| info.resize( infoSize ); | |
| } | |
| return createResultValue( result, info, VULKAN_HPP_NAMESPACE_STRING "::Device::getShaderInfoAMD" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #if defined( VK_USE_PLATFORM_GGP ) | |
| //=== VK_GGP_stream_descriptor_surface === | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createStreamDescriptorSurfaceGGP( | |
| const VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP * pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkCreateStreamDescriptorSurfaceGGP( | |
| m_instance, | |
| reinterpret_cast<const VkStreamDescriptorSurfaceCreateInfoGGP *>( pCreateInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), | |
| reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) ); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type | |
| Instance::createStreamDescriptorSurfaceGGP( | |
| const VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP & createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface; | |
| Result result = static_cast<Result>( d.vkCreateStreamDescriptorSurfaceGGP( | |
| m_instance, | |
| reinterpret_cast<const VkStreamDescriptorSurfaceCreateInfoGGP *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkSurfaceKHR *>( &surface ) ) ); | |
| return createResultValue( | |
| result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createStreamDescriptorSurfaceGGP" ); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type | |
| Instance::createStreamDescriptorSurfaceGGPUnique( | |
| const VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP & createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface; | |
| Result result = static_cast<Result>( d.vkCreateStreamDescriptorSurfaceGGP( | |
| m_instance, | |
| reinterpret_cast<const VkStreamDescriptorSurfaceCreateInfoGGP *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkSurfaceKHR *>( &surface ) ) ); | |
| ObjectDestroy<Instance, Dispatch> deleter( *this, allocator, d ); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>( | |
| result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createStreamDescriptorSurfaceGGPUnique", deleter ); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #endif /*VK_USE_PLATFORM_GGP*/ | |
| //=== VK_NV_external_memory_capabilities === | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getExternalImageFormatPropertiesNV( | |
| VULKAN_HPP_NAMESPACE::Format format, | |
| VULKAN_HPP_NAMESPACE::ImageType type, | |
| VULKAN_HPP_NAMESPACE::ImageTiling tiling, | |
| VULKAN_HPP_NAMESPACE::ImageUsageFlags usage, | |
| VULKAN_HPP_NAMESPACE::ImageCreateFlags flags, | |
| VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV externalHandleType, | |
| VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV * pExternalImageFormatProperties, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkGetPhysicalDeviceExternalImageFormatPropertiesNV( | |
| m_physicalDevice, | |
| static_cast<VkFormat>( format ), | |
| static_cast<VkImageType>( type ), | |
| static_cast<VkImageTiling>( tiling ), | |
| static_cast<VkImageUsageFlags>( usage ), | |
| static_cast<VkImageCreateFlags>( flags ), | |
| static_cast<VkExternalMemoryHandleTypeFlagsNV>( externalHandleType ), | |
| reinterpret_cast<VkExternalImageFormatPropertiesNV *>( pExternalImageFormatProperties ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV>::type | |
| PhysicalDevice::getExternalImageFormatPropertiesNV( | |
| VULKAN_HPP_NAMESPACE::Format format, | |
| VULKAN_HPP_NAMESPACE::ImageType type, | |
| VULKAN_HPP_NAMESPACE::ImageTiling tiling, | |
| VULKAN_HPP_NAMESPACE::ImageUsageFlags usage, | |
| VULKAN_HPP_NAMESPACE::ImageCreateFlags flags, | |
| VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV externalHandleType, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV externalImageFormatProperties; | |
| Result result = static_cast<Result>( d.vkGetPhysicalDeviceExternalImageFormatPropertiesNV( | |
| m_physicalDevice, | |
| static_cast<VkFormat>( format ), | |
| static_cast<VkImageType>( type ), | |
| static_cast<VkImageTiling>( tiling ), | |
| static_cast<VkImageUsageFlags>( usage ), | |
| static_cast<VkImageCreateFlags>( flags ), | |
| static_cast<VkExternalMemoryHandleTypeFlagsNV>( externalHandleType ), | |
| reinterpret_cast<VkExternalImageFormatPropertiesNV *>( &externalImageFormatProperties ) ) ); | |
| return createResultValue( result, | |
| externalImageFormatProperties, | |
| VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getExternalImageFormatPropertiesNV" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #if defined( VK_USE_PLATFORM_WIN32_KHR ) | |
| //=== VK_NV_external_memory_win32 === | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::getMemoryWin32HandleNV( VULKAN_HPP_NAMESPACE::DeviceMemory memory, | |
| VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleType, | |
| HANDLE * pHandle, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkGetMemoryWin32HandleNV( m_device, | |
| static_cast<VkDeviceMemory>( memory ), | |
| static_cast<VkExternalMemoryHandleTypeFlagsNV>( handleType ), | |
| pHandle ) ); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<HANDLE>::type | |
| Device::getMemoryWin32HandleNV( VULKAN_HPP_NAMESPACE::DeviceMemory memory, | |
| VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleType, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| HANDLE handle; | |
| Result result = | |
| static_cast<Result>( d.vkGetMemoryWin32HandleNV( m_device, | |
| static_cast<VkDeviceMemory>( memory ), | |
| static_cast<VkExternalMemoryHandleTypeFlagsNV>( handleType ), | |
| &handle ) ); | |
| return createResultValue( result, handle, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryWin32HandleNV" ); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #endif /*VK_USE_PLATFORM_WIN32_KHR*/ | |
| //=== VK_KHR_get_physical_device_properties2 === | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void PhysicalDevice::getFeatures2KHR( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 * pFeatures, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkGetPhysicalDeviceFeatures2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2 *>( pFeatures ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 | |
| PhysicalDevice::getFeatures2KHR( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 features; | |
| d.vkGetPhysicalDeviceFeatures2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2 *>( &features ) ); | |
| return features; | |
| } | |
| template <typename X, typename Y, typename... Z, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> | |
| PhysicalDevice::getFeatures2KHR( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| StructureChain<X, Y, Z...> structureChain; | |
| VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 & features = | |
| structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2>(); | |
| d.vkGetPhysicalDeviceFeatures2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2 *>( &features ) ); | |
| return structureChain; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| PhysicalDevice::getProperties2KHR( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 * pProperties, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkGetPhysicalDeviceProperties2KHR( m_physicalDevice, | |
| reinterpret_cast<VkPhysicalDeviceProperties2 *>( pProperties ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 | |
| PhysicalDevice::getProperties2KHR( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 properties; | |
| d.vkGetPhysicalDeviceProperties2KHR( m_physicalDevice, | |
| reinterpret_cast<VkPhysicalDeviceProperties2 *>( &properties ) ); | |
| return properties; | |
| } | |
| template <typename X, typename Y, typename... Z, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> | |
| PhysicalDevice::getProperties2KHR( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| StructureChain<X, Y, Z...> structureChain; | |
| VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 & properties = | |
| structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2>(); | |
| d.vkGetPhysicalDeviceProperties2KHR( m_physicalDevice, | |
| reinterpret_cast<VkPhysicalDeviceProperties2 *>( &properties ) ); | |
| return structureChain; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| PhysicalDevice::getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format, | |
| VULKAN_HPP_NAMESPACE::FormatProperties2 * pFormatProperties, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkGetPhysicalDeviceFormatProperties2KHR( | |
| m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2 *>( pFormatProperties ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::FormatProperties2 | |
| PhysicalDevice::getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::FormatProperties2 formatProperties; | |
| d.vkGetPhysicalDeviceFormatProperties2KHR( | |
| m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2 *>( &formatProperties ) ); | |
| return formatProperties; | |
| } | |
| template <typename X, typename Y, typename... Z, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> | |
| PhysicalDevice::getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| StructureChain<X, Y, Z...> structureChain; | |
| VULKAN_HPP_NAMESPACE::FormatProperties2 & formatProperties = | |
| structureChain.template get<VULKAN_HPP_NAMESPACE::FormatProperties2>(); | |
| d.vkGetPhysicalDeviceFormatProperties2KHR( | |
| m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2 *>( &formatProperties ) ); | |
| return structureChain; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getImageFormatProperties2KHR( | |
| const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 * pImageFormatInfo, | |
| VULKAN_HPP_NAMESPACE::ImageFormatProperties2 * pImageFormatProperties, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2KHR( | |
| m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>( pImageFormatInfo ), | |
| reinterpret_cast<VkImageFormatProperties2 *>( pImageFormatProperties ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>::type | |
| PhysicalDevice::getImageFormatProperties2KHR( | |
| const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::ImageFormatProperties2 imageFormatProperties; | |
| Result result = static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2KHR( | |
| m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>( &imageFormatInfo ), | |
| reinterpret_cast<VkImageFormatProperties2 *>( &imageFormatProperties ) ) ); | |
| return createResultValue( | |
| result, imageFormatProperties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2KHR" ); | |
| } | |
| template <typename X, typename Y, typename... Z, typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<StructureChain<X, Y, Z...>>::type | |
| PhysicalDevice::getImageFormatProperties2KHR( | |
| const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| StructureChain<X, Y, Z...> structureChain; | |
| VULKAN_HPP_NAMESPACE::ImageFormatProperties2 & imageFormatProperties = | |
| structureChain.template get<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>(); | |
| Result result = static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2KHR( | |
| m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>( &imageFormatInfo ), | |
| reinterpret_cast<VkImageFormatProperties2 *>( &imageFormatProperties ) ) ); | |
| return createResultValue( | |
| result, structureChain, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2KHR" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| PhysicalDevice::getQueueFamilyProperties2KHR( uint32_t * pQueueFamilyPropertyCount, | |
| VULKAN_HPP_NAMESPACE::QueueFamilyProperties2 * pQueueFamilyProperties, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( | |
| m_physicalDevice, | |
| pQueueFamilyPropertyCount, | |
| reinterpret_cast<VkQueueFamilyProperties2 *>( pQueueFamilyProperties ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename QueueFamilyProperties2Allocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator> | |
| PhysicalDevice::getQueueFamilyProperties2KHR( Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator> queueFamilyProperties; | |
| uint32_t queueFamilyPropertyCount; | |
| d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, nullptr ); | |
| queueFamilyProperties.resize( queueFamilyPropertyCount ); | |
| d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( | |
| m_physicalDevice, | |
| &queueFamilyPropertyCount, | |
| reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) ); | |
| VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() ); | |
| return queueFamilyProperties; | |
| } | |
| template <typename QueueFamilyProperties2Allocator, | |
| typename Dispatch, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, QueueFamilyProperties2>::value, int>::type> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator> | |
| PhysicalDevice::getQueueFamilyProperties2KHR( QueueFamilyProperties2Allocator & queueFamilyProperties2Allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator> queueFamilyProperties( | |
| queueFamilyProperties2Allocator ); | |
| uint32_t queueFamilyPropertyCount; | |
| d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, nullptr ); | |
| queueFamilyProperties.resize( queueFamilyPropertyCount ); | |
| d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( | |
| m_physicalDevice, | |
| &queueFamilyPropertyCount, | |
| reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) ); | |
| VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() ); | |
| return queueFamilyProperties; | |
| } | |
| template <typename StructureChain, typename StructureChainAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<StructureChain, StructureChainAllocator> | |
| PhysicalDevice::getQueueFamilyProperties2KHR( Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| uint32_t queueFamilyPropertyCount; | |
| d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, nullptr ); | |
| std::vector<StructureChain, StructureChainAllocator> returnVector( queueFamilyPropertyCount ); | |
| std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> queueFamilyProperties( queueFamilyPropertyCount ); | |
| for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ ) | |
| { | |
| queueFamilyProperties[i].pNext = | |
| returnVector[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>().pNext; | |
| } | |
| d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( | |
| m_physicalDevice, | |
| &queueFamilyPropertyCount, | |
| reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) ); | |
| VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() ); | |
| for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ ) | |
| { | |
| returnVector[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>() = queueFamilyProperties[i]; | |
| } | |
| return returnVector; | |
| } | |
| template <typename StructureChain, | |
| typename StructureChainAllocator, | |
| typename Dispatch, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, StructureChain>::value, int>::type> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<StructureChain, StructureChainAllocator> | |
| PhysicalDevice::getQueueFamilyProperties2KHR( StructureChainAllocator & structureChainAllocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| uint32_t queueFamilyPropertyCount; | |
| d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, nullptr ); | |
| std::vector<StructureChain, StructureChainAllocator> returnVector( queueFamilyPropertyCount, | |
| structureChainAllocator ); | |
| std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> queueFamilyProperties( queueFamilyPropertyCount ); | |
| for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ ) | |
| { | |
| queueFamilyProperties[i].pNext = | |
| returnVector[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>().pNext; | |
| } | |
| d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( | |
| m_physicalDevice, | |
| &queueFamilyPropertyCount, | |
| reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) ); | |
| VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() ); | |
| for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ ) | |
| { | |
| returnVector[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>() = queueFamilyProperties[i]; | |
| } | |
| return returnVector; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| PhysicalDevice::getMemoryProperties2KHR( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 * pMemoryProperties, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkGetPhysicalDeviceMemoryProperties2KHR( | |
| m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>( pMemoryProperties ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 | |
| PhysicalDevice::getMemoryProperties2KHR( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 memoryProperties; | |
| d.vkGetPhysicalDeviceMemoryProperties2KHR( | |
| m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>( &memoryProperties ) ); | |
| return memoryProperties; | |
| } | |
| template <typename X, typename Y, typename... Z, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> | |
| PhysicalDevice::getMemoryProperties2KHR( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| StructureChain<X, Y, Z...> structureChain; | |
| VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 & memoryProperties = | |
| structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2>(); | |
| d.vkGetPhysicalDeviceMemoryProperties2KHR( | |
| m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>( &memoryProperties ) ); | |
| return structureChain; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void PhysicalDevice::getSparseImageFormatProperties2KHR( | |
| const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 * pFormatInfo, | |
| uint32_t * pPropertyCount, | |
| VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 * pProperties, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR( | |
| m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( pFormatInfo ), | |
| pPropertyCount, | |
| reinterpret_cast<VkSparseImageFormatProperties2 *>( pProperties ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename SparseImageFormatProperties2Allocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD | |
| VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator> | |
| PhysicalDevice::getSparseImageFormatProperties2KHR( | |
| const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator> properties; | |
| uint32_t propertyCount; | |
| d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR( | |
| m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ), | |
| &propertyCount, | |
| nullptr ); | |
| properties.resize( propertyCount ); | |
| d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR( | |
| m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ), | |
| &propertyCount, | |
| reinterpret_cast<VkSparseImageFormatProperties2 *>( properties.data() ) ); | |
| VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); | |
| return properties; | |
| } | |
| template < | |
| typename SparseImageFormatProperties2Allocator, | |
| typename Dispatch, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, SparseImageFormatProperties2>::value, int>::type> | |
| VULKAN_HPP_NODISCARD | |
| VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator> | |
| PhysicalDevice::getSparseImageFormatProperties2KHR( | |
| const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo, | |
| SparseImageFormatProperties2Allocator & sparseImageFormatProperties2Allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator> properties( | |
| sparseImageFormatProperties2Allocator ); | |
| uint32_t propertyCount; | |
| d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR( | |
| m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ), | |
| &propertyCount, | |
| nullptr ); | |
| properties.resize( propertyCount ); | |
| d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR( | |
| m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ), | |
| &propertyCount, | |
| reinterpret_cast<VkSparseImageFormatProperties2 *>( properties.data() ) ); | |
| VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); | |
| return properties; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_KHR_device_group === | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| Device::getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, | |
| uint32_t localDeviceIndex, | |
| uint32_t remoteDeviceIndex, | |
| VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags * pPeerMemoryFeatures, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkGetDeviceGroupPeerMemoryFeaturesKHR( m_device, | |
| heapIndex, | |
| localDeviceIndex, | |
| remoteDeviceIndex, | |
| reinterpret_cast<VkPeerMemoryFeatureFlags *>( pPeerMemoryFeatures ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags | |
| Device::getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, | |
| uint32_t localDeviceIndex, | |
| uint32_t remoteDeviceIndex, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags peerMemoryFeatures; | |
| d.vkGetDeviceGroupPeerMemoryFeaturesKHR( m_device, | |
| heapIndex, | |
| localDeviceIndex, | |
| remoteDeviceIndex, | |
| reinterpret_cast<VkPeerMemoryFeatureFlags *>( &peerMemoryFeatures ) ); | |
| return peerMemoryFeatures; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setDeviceMaskKHR( uint32_t deviceMask, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdSetDeviceMaskKHR( m_commandBuffer, deviceMask ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::dispatchBaseKHR( uint32_t baseGroupX, | |
| uint32_t baseGroupY, | |
| uint32_t baseGroupZ, | |
| uint32_t groupCountX, | |
| uint32_t groupCountY, | |
| uint32_t groupCountZ, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdDispatchBaseKHR( | |
| m_commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ ); | |
| } | |
| #if defined( VK_USE_PLATFORM_VI_NN ) | |
| //=== VK_NN_vi_surface === | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Instance::createViSurfaceNN( const VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN * pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkCreateViSurfaceNN( m_instance, | |
| reinterpret_cast<const VkViSurfaceCreateInfoNN *>( pCreateInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), | |
| reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) ); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type | |
| Instance::createViSurfaceNN( const VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN & createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface; | |
| Result result = static_cast<Result>( | |
| d.vkCreateViSurfaceNN( m_instance, | |
| reinterpret_cast<const VkViSurfaceCreateInfoNN *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkSurfaceKHR *>( &surface ) ) ); | |
| return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createViSurfaceNN" ); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type | |
| Instance::createViSurfaceNNUnique( const VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN & createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface; | |
| Result result = static_cast<Result>( | |
| d.vkCreateViSurfaceNN( m_instance, | |
| reinterpret_cast<const VkViSurfaceCreateInfoNN *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkSurfaceKHR *>( &surface ) ) ); | |
| ObjectDestroy<Instance, Dispatch> deleter( *this, allocator, d ); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>( | |
| result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createViSurfaceNNUnique", deleter ); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #endif /*VK_USE_PLATFORM_VI_NN*/ | |
| //=== VK_KHR_maintenance1 === | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::trimCommandPoolKHR( VULKAN_HPP_NAMESPACE::CommandPool commandPool, | |
| VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkTrimCommandPoolKHR( | |
| m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolTrimFlags>( flags ) ); | |
| } | |
| //=== VK_KHR_device_group_creation === | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::enumeratePhysicalDeviceGroupsKHR( | |
| uint32_t * pPhysicalDeviceGroupCount, | |
| VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkEnumeratePhysicalDeviceGroupsKHR( | |
| m_instance, | |
| pPhysicalDeviceGroupCount, | |
| reinterpret_cast<VkPhysicalDeviceGroupProperties *>( pPhysicalDeviceGroupProperties ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename PhysicalDeviceGroupPropertiesAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE | |
| typename ResultValueType<std::vector<PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type | |
| Instance::enumeratePhysicalDeviceGroupsKHR( Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator> physicalDeviceGroupProperties; | |
| uint32_t physicalDeviceGroupCount; | |
| Result result; | |
| do | |
| { | |
| result = | |
| static_cast<Result>( d.vkEnumeratePhysicalDeviceGroupsKHR( m_instance, &physicalDeviceGroupCount, nullptr ) ); | |
| if ( ( result == Result::eSuccess ) && physicalDeviceGroupCount ) | |
| { | |
| physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); | |
| result = static_cast<Result>( d.vkEnumeratePhysicalDeviceGroupsKHR( | |
| m_instance, | |
| &physicalDeviceGroupCount, | |
| reinterpret_cast<VkPhysicalDeviceGroupProperties *>( physicalDeviceGroupProperties.data() ) ) ); | |
| VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() ); | |
| } | |
| } while ( result == Result::eIncomplete ); | |
| if ( ( result == Result::eSuccess ) && ( physicalDeviceGroupCount < physicalDeviceGroupProperties.size() ) ) | |
| { | |
| physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); | |
| } | |
| return createResultValue( result, | |
| physicalDeviceGroupProperties, | |
| VULKAN_HPP_NAMESPACE_STRING "::Instance::enumeratePhysicalDeviceGroupsKHR" ); | |
| } | |
| template < | |
| typename PhysicalDeviceGroupPropertiesAllocator, | |
| typename Dispatch, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, PhysicalDeviceGroupProperties>::value, int>::type> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE | |
| typename ResultValueType<std::vector<PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type | |
| Instance::enumeratePhysicalDeviceGroupsKHR( | |
| PhysicalDeviceGroupPropertiesAllocator & physicalDeviceGroupPropertiesAllocator, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator> physicalDeviceGroupProperties( | |
| physicalDeviceGroupPropertiesAllocator ); | |
| uint32_t physicalDeviceGroupCount; | |
| Result result; | |
| do | |
| { | |
| result = | |
| static_cast<Result>( d.vkEnumeratePhysicalDeviceGroupsKHR( m_instance, &physicalDeviceGroupCount, nullptr ) ); | |
| if ( ( result == Result::eSuccess ) && physicalDeviceGroupCount ) | |
| { | |
| physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); | |
| result = static_cast<Result>( d.vkEnumeratePhysicalDeviceGroupsKHR( | |
| m_instance, | |
| &physicalDeviceGroupCount, | |
| reinterpret_cast<VkPhysicalDeviceGroupProperties *>( physicalDeviceGroupProperties.data() ) ) ); | |
| VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() ); | |
| } | |
| } while ( result == Result::eIncomplete ); | |
| if ( ( result == Result::eSuccess ) && ( physicalDeviceGroupCount < physicalDeviceGroupProperties.size() ) ) | |
| { | |
| physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); | |
| } | |
| return createResultValue( result, | |
| physicalDeviceGroupProperties, | |
| VULKAN_HPP_NAMESPACE_STRING "::Instance::enumeratePhysicalDeviceGroupsKHR" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_KHR_external_memory_capabilities === | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void PhysicalDevice::getExternalBufferPropertiesKHR( | |
| const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo * pExternalBufferInfo, | |
| VULKAN_HPP_NAMESPACE::ExternalBufferProperties * pExternalBufferProperties, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkGetPhysicalDeviceExternalBufferPropertiesKHR( | |
| m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo *>( pExternalBufferInfo ), | |
| reinterpret_cast<VkExternalBufferProperties *>( pExternalBufferProperties ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalBufferProperties | |
| PhysicalDevice::getExternalBufferPropertiesKHR( | |
| const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo & externalBufferInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::ExternalBufferProperties externalBufferProperties; | |
| d.vkGetPhysicalDeviceExternalBufferPropertiesKHR( | |
| m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo *>( &externalBufferInfo ), | |
| reinterpret_cast<VkExternalBufferProperties *>( &externalBufferProperties ) ); | |
| return externalBufferProperties; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #if defined( VK_USE_PLATFORM_WIN32_KHR ) | |
| //=== VK_KHR_external_memory_win32 === | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::getMemoryWin32HandleKHR( const VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR * pGetWin32HandleInfo, | |
| HANDLE * pHandle, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkGetMemoryWin32HandleKHR( | |
| m_device, reinterpret_cast<const VkMemoryGetWin32HandleInfoKHR *>( pGetWin32HandleInfo ), pHandle ) ); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<HANDLE>::type | |
| Device::getMemoryWin32HandleKHR( const VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR & getWin32HandleInfo, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| HANDLE handle; | |
| Result result = static_cast<Result>( d.vkGetMemoryWin32HandleKHR( | |
| m_device, reinterpret_cast<const VkMemoryGetWin32HandleInfoKHR *>( &getWin32HandleInfo ), &handle ) ); | |
| return createResultValue( result, handle, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryWin32HandleKHR" ); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getMemoryWin32HandlePropertiesKHR( | |
| VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, | |
| HANDLE handle, | |
| VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR * pMemoryWin32HandleProperties, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkGetMemoryWin32HandlePropertiesKHR( | |
| m_device, | |
| static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ), | |
| handle, | |
| reinterpret_cast<VkMemoryWin32HandlePropertiesKHR *>( pMemoryWin32HandleProperties ) ) ); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR>::type | |
| Device::getMemoryWin32HandlePropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, | |
| HANDLE handle, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR memoryWin32HandleProperties; | |
| Result result = static_cast<Result>( d.vkGetMemoryWin32HandlePropertiesKHR( | |
| m_device, | |
| static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ), | |
| handle, | |
| reinterpret_cast<VkMemoryWin32HandlePropertiesKHR *>( &memoryWin32HandleProperties ) ) ); | |
| return createResultValue( | |
| result, memoryWin32HandleProperties, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryWin32HandlePropertiesKHR" ); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #endif /*VK_USE_PLATFORM_WIN32_KHR*/ | |
| //=== VK_KHR_external_memory_fd === | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::getMemoryFdKHR( const VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR * pGetFdInfo, | |
| int * pFd, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkGetMemoryFdKHR( m_device, reinterpret_cast<const VkMemoryGetFdInfoKHR *>( pGetFdInfo ), pFd ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<int>::type | |
| Device::getMemoryFdKHR( const VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR & getFdInfo, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| int fd; |