| // 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 InstanceCreateInfo & createInfo, | |
| Optional<const 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 InstanceCreateInfo & createInfo, | |
| Optional<const 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 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 DeviceCreateInfo & createInfo, | |
| Optional<const 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 DeviceCreateInfo & createInfo, | |
| Optional<const 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 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 MemoryAllocateInfo & allocateInfo, | |
| Optional<const 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 MemoryAllocateInfo & allocateInfo, | |
| Optional<const 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 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 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 FenceCreateInfo & createInfo, | |
| Optional<const 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 FenceCreateInfo & createInfo, | |
| Optional<const 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 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 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 SemaphoreCreateInfo & createInfo, | |
| Optional<const 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 SemaphoreCreateInfo & createInfo, | |
| Optional<const 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 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 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 EventCreateInfo & createInfo, | |
| Optional<const 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 EventCreateInfo & createInfo, | |
| Optional<const 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 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 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 QueryPoolCreateInfo & createInfo, | |
| Optional<const 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 QueryPoolCreateInfo & createInfo, | |
| Optional<const 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 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 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 BufferCreateInfo & createInfo, | |
| Optional<const 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 BufferCreateInfo & createInfo, | |
| Optional<const 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 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 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 BufferViewCreateInfo & createInfo, | |
| Optional<const 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 BufferViewCreateInfo & createInfo, | |
| Optional<const 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 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 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 ImageCreateInfo & createInfo, | |
| Optional<const 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 ImageCreateInfo & createInfo, | |
| Optional<const 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 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 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 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 ImageViewCreateInfo & createInfo, | |
| Optional<const 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 ImageViewCreateInfo & createInfo, | |
| Optional<const 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 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 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 ShaderModuleCreateInfo & createInfo, | |
| Optional<const 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 ShaderModuleCreateInfo & createInfo, | |
| Optional<const 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 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 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 PipelineCacheCreateInfo & createInfo, | |
| Optional<const 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 PipelineCacheCreateInfo & createInfo, | |
| Optional<const 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 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 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<Pipeline, PipelineAllocator>> | |
| Device::createGraphicsPipelines( | |
| VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos, | |
| Optional<const AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<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<Pipeline, PipelineAllocator>> | |
| Device::createGraphicsPipelines( | |
| VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos, | |
| Optional<const AllocationCallbacks> allocator, | |
| PipelineAllocator & pipelineAllocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<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<Pipeline> | |
| Device::createGraphicsPipeline( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo & createInfo, | |
| Optional<const 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 ) ) ); | |
| 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 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 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 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<Pipeline, PipelineAllocator>> | |
| Device::createComputePipelines( | |
| VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos, | |
| Optional<const AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<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<Pipeline, PipelineAllocator>> | |
| Device::createComputePipelines( | |
| VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos, | |
| Optional<const AllocationCallbacks> allocator, | |
| PipelineAllocator & pipelineAllocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<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<Pipeline> | |
| Device::createComputePipeline( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo & createInfo, | |
| Optional<const 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 ) ) ); | |
| 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 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 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 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 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 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 PipelineLayoutCreateInfo & createInfo, | |
| Optional<const 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 PipelineLayoutCreateInfo & createInfo, | |
| Optional<const 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 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 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 SamplerCreateInfo & createInfo, | |
| Optional<const 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 SamplerCreateInfo & createInfo, | |
| Optional<const 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 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 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 DescriptorSetLayoutCreateInfo & createInfo, | |
| Optional<const 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 DescriptorSetLayoutCreateInfo & createInfo, | |
| Optional<const 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 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 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 DescriptorPoolCreateInfo & createInfo, | |
| Optional<const 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 DescriptorPoolCreateInfo & createInfo, | |
| Optional<const 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 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 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<DescriptorSet, DescriptorSetAllocator>>::type | |
| Device::allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<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<DescriptorSet, DescriptorSetAllocator>>::type | |
| Device::allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo, | |
| DescriptorSetAllocator & descriptorSetAllocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<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 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 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 FramebufferCreateInfo & createInfo, | |
| Optional<const 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 FramebufferCreateInfo & createInfo, | |
| Optional<const 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 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 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 RenderPassCreateInfo & createInfo, | |
| Optional<const 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 RenderPassCreateInfo & createInfo, | |
| Optional<const 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 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 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 CommandPoolCreateInfo & createInfo, | |
| Optional<const 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 CommandPoolCreateInfo & createInfo, | |
| Optional<const 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 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 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<CommandBuffer, CommandBufferAllocator>>::type | |
| Device::allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<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<CommandBuffer, CommandBufferAllocator>>::type | |
| Device::allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo, | |
| CommandBufferAllocator & commandBufferAllocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 SamplerYcbcrConversionCreateInfo & createInfo, | |
| Optional<const 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 SamplerYcbcrConversionCreateInfo & createInfo, | |
| Optional<const 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 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 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 DescriptorUpdateTemplateCreateInfo & createInfo, | |
| Optional<const 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 DescriptorUpdateTemplateCreateInfo & createInfo, | |
| Optional<const 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 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 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 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 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 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 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 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 RenderPassCreateInfo2 & createInfo, | |
| Optional<const 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 RenderPassCreateInfo2 & createInfo, | |
| Optional<const 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 RenderPassBeginInfo & renderPassBegin, | |
| const 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 SubpassBeginInfo & subpassBeginInfo, | |
| const 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 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 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 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 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 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 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 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 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 SwapchainCreateInfoKHR & createInfo, | |
| Optional<const 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 SwapchainCreateInfoKHR & createInfo, | |
| Optional<const 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 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 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 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 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 DisplayModeCreateInfoKHR & createInfo, | |
| Optional<const 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 DisplayModeCreateInfoKHR & createInfo, | |
| Optional<const 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 DisplaySurfaceCreateInfoKHR & createInfo, | |
| Optional<const 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 DisplaySurfaceCreateInfoKHR & createInfo, | |
| Optional<const 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<SwapchainKHR, SwapchainKHRAllocator>>::type | |
| Device::createSharedSwapchainsKHR( | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos, | |
| Optional<const AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<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<SwapchainKHR, SwapchainKHRAllocator>>::type | |
| Device::createSharedSwapchainsKHR( | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos, | |
| Optional<const AllocationCallbacks> allocator, | |
| SwapchainKHRAllocator & swapchainKHRAllocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<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<SwapchainKHR>::type | |
| Device::createSharedSwapchainKHR( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR & createInfo, | |
| Optional<const 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 ) ) ); | |
| 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 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 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 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 XlibSurfaceCreateInfoKHR & createInfo, | |
| Optional<const 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 XlibSurfaceCreateInfoKHR & createInfo, | |
| Optional<const 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 XcbSurfaceCreateInfoKHR & createInfo, | |
| Optional<const 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 XcbSurfaceCreateInfoKHR & createInfo, | |
| Optional<const 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 WaylandSurfaceCreateInfoKHR & createInfo, | |
| Optional<const 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 WaylandSurfaceCreateInfoKHR & createInfo, | |
| Optional<const 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 AndroidSurfaceCreateInfoKHR & createInfo, | |
| Optional<const 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 AndroidSurfaceCreateInfoKHR & createInfo, | |
| Optional<const 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 Win32SurfaceCreateInfoKHR & createInfo, | |
| Optional<const 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 Win32SurfaceCreateInfoKHR & createInfo, | |
| Optional<const 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 DebugReportCallbackCreateInfoEXT & createInfo, | |
| Optional<const 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 DebugReportCallbackCreateInfoEXT & createInfo, | |
| Optional<const 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 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 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 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 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 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 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 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 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 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 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 VideoSessionCreateInfoKHR & createInfo, | |
| Optional<const 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 VideoSessionCreateInfoKHR & createInfo, | |
| Optional<const 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 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 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 VideoSessionParametersCreateInfoKHR & createInfo, | |
| Optional<const 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 VideoSessionParametersCreateInfoKHR & createInfo, | |
| Optional<const 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 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 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 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 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 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 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 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 CuModuleCreateInfoNVX & createInfo, | |
| Optional<const 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 CuModuleCreateInfoNVX & createInfo, | |
| Optional<const 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 CuFunctionCreateInfoNVX & createInfo, | |
| Optional<const 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 CuFunctionCreateInfoNVX & createInfo, | |
| Optional<const 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 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 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 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 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 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 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 StreamDescriptorSurfaceCreateInfoGGP & createInfo, | |
| Optional<const 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 StreamDescriptorSurfaceCreateInfoGGP & createInfo, | |
| Optional<const 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 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 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 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 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 ViSurfaceCreateInfoNN & createInfo, | |
| Optional<const 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 ViSurfaceCreateInfoNN & createInfo, | |
| Optional<const 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 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 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 MemoryGetFdInfoKHR & getFdInfo, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| int fd; | |
| Result result = static_cast<Result>( | |
| d.vkGetMemoryFdKHR( m_device, reinterpret_cast<const VkMemoryGetFdInfoKHR *>( &getFdInfo ), &fd ) ); | |
| return createResultValue( result, fd, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryFdKHR" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::getMemoryFdPropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, | |
| int fd, | |
| VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR * pMemoryFdProperties, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkGetMemoryFdPropertiesKHR( m_device, | |
| static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ), | |
| fd, | |
| reinterpret_cast<VkMemoryFdPropertiesKHR *>( pMemoryFdProperties ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR>::type | |
| Device::getMemoryFdPropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, | |
| int fd, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR memoryFdProperties; | |
| Result result = static_cast<Result>( | |
| d.vkGetMemoryFdPropertiesKHR( m_device, | |
| static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ), | |
| fd, | |
| reinterpret_cast<VkMemoryFdPropertiesKHR *>( &memoryFdProperties ) ) ); | |
| return createResultValue( | |
| result, memoryFdProperties, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryFdPropertiesKHR" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_KHR_external_semaphore_capabilities === | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void PhysicalDevice::getExternalSemaphorePropertiesKHR( | |
| const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo, | |
| VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties * pExternalSemaphoreProperties, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( | |
| m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo *>( pExternalSemaphoreInfo ), | |
| reinterpret_cast<VkExternalSemaphoreProperties *>( pExternalSemaphoreProperties ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties | |
| PhysicalDevice::getExternalSemaphorePropertiesKHR( | |
| const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties externalSemaphoreProperties; | |
| d.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( | |
| m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo *>( &externalSemaphoreInfo ), | |
| reinterpret_cast<VkExternalSemaphoreProperties *>( &externalSemaphoreProperties ) ); | |
| return externalSemaphoreProperties; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #if defined( VK_USE_PLATFORM_WIN32_KHR ) | |
| //=== VK_KHR_external_semaphore_win32 === | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::importSemaphoreWin32HandleKHR( | |
| const VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR * pImportSemaphoreWin32HandleInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkImportSemaphoreWin32HandleKHR( | |
| m_device, reinterpret_cast<const VkImportSemaphoreWin32HandleInfoKHR *>( pImportSemaphoreWin32HandleInfo ) ) ); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| Device::importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| Result result = static_cast<Result>( d.vkImportSemaphoreWin32HandleKHR( | |
| m_device, reinterpret_cast<const VkImportSemaphoreWin32HandleInfoKHR *>( &importSemaphoreWin32HandleInfo ) ) ); | |
| return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::importSemaphoreWin32HandleKHR" ); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSemaphoreWin32HandleKHR( | |
| const VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR * pGetWin32HandleInfo, | |
| HANDLE * pHandle, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkGetSemaphoreWin32HandleKHR( | |
| m_device, reinterpret_cast<const VkSemaphoreGetWin32HandleInfoKHR *>( pGetWin32HandleInfo ), pHandle ) ); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<HANDLE>::type | |
| Device::getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| HANDLE handle; | |
| Result result = static_cast<Result>( d.vkGetSemaphoreWin32HandleKHR( | |
| m_device, reinterpret_cast<const VkSemaphoreGetWin32HandleInfoKHR *>( &getWin32HandleInfo ), &handle ) ); | |
| return createResultValue( result, handle, VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreWin32HandleKHR" ); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #endif /*VK_USE_PLATFORM_WIN32_KHR*/ | |
| //=== VK_KHR_external_semaphore_fd === | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::importSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR * pImportSemaphoreFdInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkImportSemaphoreFdKHR( | |
| m_device, reinterpret_cast<const VkImportSemaphoreFdInfoKHR *>( pImportSemaphoreFdInfo ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| Device::importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR & importSemaphoreFdInfo, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| Result result = static_cast<Result>( d.vkImportSemaphoreFdKHR( | |
| m_device, reinterpret_cast<const VkImportSemaphoreFdInfoKHR *>( &importSemaphoreFdInfo ) ) ); | |
| return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::importSemaphoreFdKHR" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::getSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR * pGetFdInfo, | |
| int * pFd, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkGetSemaphoreFdKHR( m_device, reinterpret_cast<const VkSemaphoreGetFdInfoKHR *>( pGetFdInfo ), pFd ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<int>::type | |
| Device::getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR & getFdInfo, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| int fd; | |
| Result result = static_cast<Result>( | |
| d.vkGetSemaphoreFdKHR( m_device, reinterpret_cast<const VkSemaphoreGetFdInfoKHR *>( &getFdInfo ), &fd ) ); | |
| return createResultValue( result, fd, VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreFdKHR" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_KHR_push_descriptor === | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::pushDescriptorSetKHR( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, | |
| VULKAN_HPP_NAMESPACE::PipelineLayout layout, | |
| uint32_t set, | |
| uint32_t descriptorWriteCount, | |
| const VULKAN_HPP_NAMESPACE::WriteDescriptorSet * pDescriptorWrites, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdPushDescriptorSetKHR( m_commandBuffer, | |
| static_cast<VkPipelineBindPoint>( pipelineBindPoint ), | |
| static_cast<VkPipelineLayout>( layout ), | |
| set, | |
| descriptorWriteCount, | |
| reinterpret_cast<const VkWriteDescriptorSet *>( pDescriptorWrites ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetKHR( | |
| VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, | |
| VULKAN_HPP_NAMESPACE::PipelineLayout layout, | |
| uint32_t set, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdPushDescriptorSetKHR( m_commandBuffer, | |
| static_cast<VkPipelineBindPoint>( pipelineBindPoint ), | |
| static_cast<VkPipelineLayout>( layout ), | |
| set, | |
| descriptorWrites.size(), | |
| reinterpret_cast<const VkWriteDescriptorSet *>( descriptorWrites.data() ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplateKHR( | |
| VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, | |
| VULKAN_HPP_NAMESPACE::PipelineLayout layout, | |
| uint32_t set, | |
| const void * pData, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdPushDescriptorSetWithTemplateKHR( m_commandBuffer, | |
| static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), | |
| static_cast<VkPipelineLayout>( layout ), | |
| set, | |
| pData ); | |
| } | |
| //=== VK_EXT_conditional_rendering === | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::beginConditionalRenderingEXT( | |
| const VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT * pConditionalRenderingBegin, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdBeginConditionalRenderingEXT( | |
| m_commandBuffer, reinterpret_cast<const VkConditionalRenderingBeginInfoEXT *>( pConditionalRenderingBegin ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::beginConditionalRenderingEXT( const ConditionalRenderingBeginInfoEXT & conditionalRenderingBegin, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdBeginConditionalRenderingEXT( | |
| m_commandBuffer, reinterpret_cast<const VkConditionalRenderingBeginInfoEXT *>( &conditionalRenderingBegin ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::endConditionalRenderingEXT( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdEndConditionalRenderingEXT( m_commandBuffer ); | |
| } | |
| //=== VK_KHR_descriptor_update_template === | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createDescriptorUpdateTemplateKHR( | |
| const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo * pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate * pDescriptorUpdateTemplate, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkCreateDescriptorUpdateTemplateKHR( | |
| m_device, | |
| reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo *>( pCreateInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), | |
| reinterpret_cast<VkDescriptorUpdateTemplate *>( pDescriptorUpdateTemplate ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate>::type | |
| Device::createDescriptorUpdateTemplateKHR( const DescriptorUpdateTemplateCreateInfo & createInfo, | |
| Optional<const 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.vkCreateDescriptorUpdateTemplateKHR( | |
| 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::createDescriptorUpdateTemplateKHR" ); | |
| } | |
| # 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::createDescriptorUpdateTemplateKHRUnique( const DescriptorUpdateTemplateCreateInfo & createInfo, | |
| Optional<const 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.vkCreateDescriptorUpdateTemplateKHR( | |
| 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::createDescriptorUpdateTemplateKHRUnique", | |
| deleter ); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| Device::destroyDescriptorUpdateTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyDescriptorUpdateTemplateKHR( m_device, | |
| static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| Device::destroyDescriptorUpdateTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, | |
| Optional<const AllocationCallbacks> allocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyDescriptorUpdateTemplateKHR( | |
| m_device, | |
| static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| Device::updateDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet, | |
| VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, | |
| const void * pData, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkUpdateDescriptorSetWithTemplateKHR( m_device, | |
| static_cast<VkDescriptorSet>( descriptorSet ), | |
| static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), | |
| pData ); | |
| } | |
| //=== VK_NV_clip_space_w_scaling === | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::setViewportWScalingNV( uint32_t firstViewport, | |
| uint32_t viewportCount, | |
| const VULKAN_HPP_NAMESPACE::ViewportWScalingNV * pViewportWScalings, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdSetViewportWScalingNV( m_commandBuffer, | |
| firstViewport, | |
| viewportCount, | |
| reinterpret_cast<const VkViewportWScalingNV *>( pViewportWScalings ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setViewportWScalingNV( | |
| uint32_t firstViewport, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::ViewportWScalingNV> const & viewportWScalings, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdSetViewportWScalingNV( m_commandBuffer, | |
| firstViewport, | |
| viewportWScalings.size(), | |
| reinterpret_cast<const VkViewportWScalingNV *>( viewportWScalings.data() ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_EXT_direct_mode_display === | |
| #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE Result PhysicalDevice::releaseDisplayEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkReleaseDisplayEXT( m_physicalDevice, static_cast<VkDisplayKHR>( display ) ) ); | |
| } | |
| #else | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| PhysicalDevice::releaseDisplayEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| Result result = | |
| static_cast<Result>( d.vkReleaseDisplayEXT( m_physicalDevice, static_cast<VkDisplayKHR>( display ) ) ); | |
| return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::releaseDisplayEXT" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT ) | |
| //=== VK_EXT_acquire_xlib_display === | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::acquireXlibDisplayEXT( | |
| Display * dpy, VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkAcquireXlibDisplayEXT( m_physicalDevice, dpy, static_cast<VkDisplayKHR>( display ) ) ); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| PhysicalDevice::acquireXlibDisplayEXT( Display & dpy, | |
| VULKAN_HPP_NAMESPACE::DisplayKHR display, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| Result result = | |
| static_cast<Result>( d.vkAcquireXlibDisplayEXT( m_physicalDevice, &dpy, static_cast<VkDisplayKHR>( display ) ) ); | |
| return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::acquireXlibDisplayEXT" ); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| PhysicalDevice::getRandROutputDisplayEXT( Display * dpy, | |
| RROutput rrOutput, | |
| VULKAN_HPP_NAMESPACE::DisplayKHR * pDisplay, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkGetRandROutputDisplayEXT( m_physicalDevice, dpy, rrOutput, reinterpret_cast<VkDisplayKHR *>( pDisplay ) ) ); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayKHR>::type | |
| PhysicalDevice::getRandROutputDisplayEXT( Display & dpy, RROutput rrOutput, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::DisplayKHR display; | |
| Result result = static_cast<Result>( | |
| d.vkGetRandROutputDisplayEXT( m_physicalDevice, &dpy, rrOutput, reinterpret_cast<VkDisplayKHR *>( &display ) ) ); | |
| return createResultValue( | |
| result, display, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getRandROutputDisplayEXT" ); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>>::type | |
| PhysicalDevice::getRandROutputDisplayEXTUnique( Display & dpy, RROutput rrOutput, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::DisplayKHR display; | |
| Result result = static_cast<Result>( | |
| d.vkGetRandROutputDisplayEXT( m_physicalDevice, &dpy, rrOutput, reinterpret_cast<VkDisplayKHR *>( &display ) ) ); | |
| ObjectRelease<PhysicalDevice, Dispatch> deleter( *this, d ); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>( | |
| result, display, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getRandROutputDisplayEXTUnique", deleter ); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ | |
| //=== VK_EXT_display_surface_counter === | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| PhysicalDevice::getSurfaceCapabilities2EXT( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, | |
| VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT * pSurfaceCapabilities, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilities2EXT( | |
| m_physicalDevice, | |
| static_cast<VkSurfaceKHR>( surface ), | |
| reinterpret_cast<VkSurfaceCapabilities2EXT *>( pSurfaceCapabilities ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT>::type | |
| PhysicalDevice::getSurfaceCapabilities2EXT( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT surfaceCapabilities; | |
| Result result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilities2EXT( | |
| m_physicalDevice, | |
| static_cast<VkSurfaceKHR>( surface ), | |
| reinterpret_cast<VkSurfaceCapabilities2EXT *>( &surfaceCapabilities ) ) ); | |
| return createResultValue( | |
| result, surfaceCapabilities, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilities2EXT" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_EXT_display_control === | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::displayPowerControlEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, | |
| const VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT * pDisplayPowerInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkDisplayPowerControlEXT( m_device, | |
| static_cast<VkDisplayKHR>( display ), | |
| reinterpret_cast<const VkDisplayPowerInfoEXT *>( pDisplayPowerInfo ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::displayPowerControlEXT( | |
| VULKAN_HPP_NAMESPACE::DisplayKHR display, const DisplayPowerInfoEXT & displayPowerInfo, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| Result result = static_cast<Result>( | |
| d.vkDisplayPowerControlEXT( m_device, | |
| static_cast<VkDisplayKHR>( display ), | |
| reinterpret_cast<const VkDisplayPowerInfoEXT *>( &displayPowerInfo ) ) ); | |
| return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::displayPowerControlEXT" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::registerEventEXT( const VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT * pDeviceEventInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| VULKAN_HPP_NAMESPACE::Fence * pFence, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkRegisterDeviceEventEXT( m_device, | |
| reinterpret_cast<const VkDeviceEventInfoEXT *>( pDeviceEventInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), | |
| reinterpret_cast<VkFence *>( pFence ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::Fence>::type | |
| Device::registerEventEXT( const DeviceEventInfoEXT & deviceEventInfo, | |
| Optional<const 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.vkRegisterDeviceEventEXT( m_device, | |
| reinterpret_cast<const VkDeviceEventInfoEXT *>( &deviceEventInfo ), | |
| 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::registerEventEXT" ); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>>::type | |
| Device::registerEventEXTUnique( const DeviceEventInfoEXT & deviceEventInfo, | |
| Optional<const 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.vkRegisterDeviceEventEXT( m_device, | |
| reinterpret_cast<const VkDeviceEventInfoEXT *>( &deviceEventInfo ), | |
| 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::registerEventEXTUnique", deleter ); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::registerDisplayEventEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, | |
| const VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT * pDisplayEventInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| VULKAN_HPP_NAMESPACE::Fence * pFence, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkRegisterDisplayEventEXT( m_device, | |
| static_cast<VkDisplayKHR>( display ), | |
| reinterpret_cast<const VkDisplayEventInfoEXT *>( pDisplayEventInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), | |
| reinterpret_cast<VkFence *>( pFence ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::Fence>::type | |
| Device::registerDisplayEventEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, | |
| const DisplayEventInfoEXT & displayEventInfo, | |
| Optional<const 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.vkRegisterDisplayEventEXT( m_device, | |
| static_cast<VkDisplayKHR>( display ), | |
| reinterpret_cast<const VkDisplayEventInfoEXT *>( &displayEventInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkFence *>( &fence ) ) ); | |
| return createResultValue( result, fence, VULKAN_HPP_NAMESPACE_STRING "::Device::registerDisplayEventEXT" ); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>>::type | |
| Device::registerDisplayEventEXTUnique( VULKAN_HPP_NAMESPACE::DisplayKHR display, | |
| const DisplayEventInfoEXT & displayEventInfo, | |
| Optional<const 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.vkRegisterDisplayEventEXT( m_device, | |
| static_cast<VkDisplayKHR>( display ), | |
| reinterpret_cast<const VkDisplayEventInfoEXT *>( &displayEventInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkFence *>( &fence ) ) ); | |
| ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d ); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::Fence, Dispatch>( | |
| result, fence, VULKAN_HPP_NAMESPACE_STRING "::Device::registerDisplayEventEXTUnique", deleter ); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::getSwapchainCounterEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, | |
| VULKAN_HPP_NAMESPACE::SurfaceCounterFlagBitsEXT counter, | |
| uint64_t * pCounterValue, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkGetSwapchainCounterEXT( m_device, | |
| static_cast<VkSwapchainKHR>( swapchain ), | |
| static_cast<VkSurfaceCounterFlagBitsEXT>( counter ), | |
| pCounterValue ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<uint64_t>::type | |
| Device::getSwapchainCounterEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, | |
| VULKAN_HPP_NAMESPACE::SurfaceCounterFlagBitsEXT counter, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| uint64_t counterValue; | |
| Result result = | |
| static_cast<Result>( d.vkGetSwapchainCounterEXT( m_device, | |
| static_cast<VkSwapchainKHR>( swapchain ), | |
| static_cast<VkSurfaceCounterFlagBitsEXT>( counter ), | |
| &counterValue ) ); | |
| return createResultValue( result, counterValue, VULKAN_HPP_NAMESPACE_STRING "::Device::getSwapchainCounterEXT" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_GOOGLE_display_timing === | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::getRefreshCycleDurationGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, | |
| VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE * pDisplayTimingProperties, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkGetRefreshCycleDurationGOOGLE( | |
| m_device, | |
| static_cast<VkSwapchainKHR>( swapchain ), | |
| reinterpret_cast<VkRefreshCycleDurationGOOGLE *>( pDisplayTimingProperties ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE>::type | |
| Device::getRefreshCycleDurationGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE displayTimingProperties; | |
| Result result = static_cast<Result>( d.vkGetRefreshCycleDurationGOOGLE( | |
| m_device, | |
| static_cast<VkSwapchainKHR>( swapchain ), | |
| reinterpret_cast<VkRefreshCycleDurationGOOGLE *>( &displayTimingProperties ) ) ); | |
| return createResultValue( | |
| result, displayTimingProperties, VULKAN_HPP_NAMESPACE_STRING "::Device::getRefreshCycleDurationGOOGLE" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::getPastPresentationTimingGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, | |
| uint32_t * pPresentationTimingCount, | |
| VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE * pPresentationTimings, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkGetPastPresentationTimingGOOGLE( | |
| m_device, | |
| static_cast<VkSwapchainKHR>( swapchain ), | |
| pPresentationTimingCount, | |
| reinterpret_cast<VkPastPresentationTimingGOOGLE *>( pPresentationTimings ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename PastPresentationTimingGOOGLEAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE | |
| typename ResultValueType<std::vector<PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator>>::type | |
| Device::getPastPresentationTimingGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator> presentationTimings; | |
| uint32_t presentationTimingCount; | |
| Result result; | |
| do | |
| { | |
| result = static_cast<Result>( d.vkGetPastPresentationTimingGOOGLE( | |
| m_device, static_cast<VkSwapchainKHR>( swapchain ), &presentationTimingCount, nullptr ) ); | |
| if ( ( result == Result::eSuccess ) && presentationTimingCount ) | |
| { | |
| presentationTimings.resize( presentationTimingCount ); | |
| result = static_cast<Result>( d.vkGetPastPresentationTimingGOOGLE( | |
| m_device, | |
| static_cast<VkSwapchainKHR>( swapchain ), | |
| &presentationTimingCount, | |
| reinterpret_cast<VkPastPresentationTimingGOOGLE *>( presentationTimings.data() ) ) ); | |
| VULKAN_HPP_ASSERT( presentationTimingCount <= presentationTimings.size() ); | |
| } | |
| } while ( result == Result::eIncomplete ); | |
| if ( ( result == Result::eSuccess ) && ( presentationTimingCount < presentationTimings.size() ) ) | |
| { | |
| presentationTimings.resize( presentationTimingCount ); | |
| } | |
| return createResultValue( | |
| result, presentationTimings, VULKAN_HPP_NAMESPACE_STRING "::Device::getPastPresentationTimingGOOGLE" ); | |
| } | |
| template < | |
| typename PastPresentationTimingGOOGLEAllocator, | |
| typename Dispatch, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, PastPresentationTimingGOOGLE>::value, int>::type> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE | |
| typename ResultValueType<std::vector<PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator>>::type | |
| Device::getPastPresentationTimingGOOGLE( | |
| VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, | |
| PastPresentationTimingGOOGLEAllocator & pastPresentationTimingGOOGLEAllocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator> presentationTimings( | |
| pastPresentationTimingGOOGLEAllocator ); | |
| uint32_t presentationTimingCount; | |
| Result result; | |
| do | |
| { | |
| result = static_cast<Result>( d.vkGetPastPresentationTimingGOOGLE( | |
| m_device, static_cast<VkSwapchainKHR>( swapchain ), &presentationTimingCount, nullptr ) ); | |
| if ( ( result == Result::eSuccess ) && presentationTimingCount ) | |
| { | |
| presentationTimings.resize( presentationTimingCount ); | |
| result = static_cast<Result>( d.vkGetPastPresentationTimingGOOGLE( | |
| m_device, | |
| static_cast<VkSwapchainKHR>( swapchain ), | |
| &presentationTimingCount, | |
| reinterpret_cast<VkPastPresentationTimingGOOGLE *>( presentationTimings.data() ) ) ); | |
| VULKAN_HPP_ASSERT( presentationTimingCount <= presentationTimings.size() ); | |
| } | |
| } while ( result == Result::eIncomplete ); | |
| if ( ( result == Result::eSuccess ) && ( presentationTimingCount < presentationTimings.size() ) ) | |
| { | |
| presentationTimings.resize( presentationTimingCount ); | |
| } | |
| return createResultValue( | |
| result, presentationTimings, VULKAN_HPP_NAMESPACE_STRING "::Device::getPastPresentationTimingGOOGLE" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_EXT_discard_rectangles === | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setDiscardRectangleEXT( uint32_t firstDiscardRectangle, | |
| uint32_t discardRectangleCount, | |
| const VULKAN_HPP_NAMESPACE::Rect2D * pDiscardRectangles, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdSetDiscardRectangleEXT( m_commandBuffer, | |
| firstDiscardRectangle, | |
| discardRectangleCount, | |
| reinterpret_cast<const VkRect2D *>( pDiscardRectangles ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::setDiscardRectangleEXT( uint32_t firstDiscardRectangle, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & discardRectangles, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdSetDiscardRectangleEXT( m_commandBuffer, | |
| firstDiscardRectangle, | |
| discardRectangles.size(), | |
| reinterpret_cast<const VkRect2D *>( discardRectangles.data() ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_EXT_hdr_metadata === | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::setHdrMetadataEXT( uint32_t swapchainCount, | |
| const VULKAN_HPP_NAMESPACE::SwapchainKHR * pSwapchains, | |
| const VULKAN_HPP_NAMESPACE::HdrMetadataEXT * pMetadata, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkSetHdrMetadataEXT( m_device, | |
| swapchainCount, | |
| reinterpret_cast<const VkSwapchainKHR *>( pSwapchains ), | |
| reinterpret_cast<const VkHdrMetadataEXT *>( pMetadata ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| Device::setHdrMetadataEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainKHR> const & swapchains, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::HdrMetadataEXT> const & metadata, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| # ifdef VULKAN_HPP_NO_EXCEPTIONS | |
| VULKAN_HPP_ASSERT( swapchains.size() == metadata.size() ); | |
| # else | |
| if ( swapchains.size() != metadata.size() ) | |
| { | |
| throw LogicError( VULKAN_HPP_NAMESPACE_STRING | |
| "::Device::setHdrMetadataEXT: swapchains.size() != metadata.size()" ); | |
| } | |
| # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ | |
| d.vkSetHdrMetadataEXT( m_device, | |
| swapchains.size(), | |
| reinterpret_cast<const VkSwapchainKHR *>( swapchains.data() ), | |
| reinterpret_cast<const VkHdrMetadataEXT *>( metadata.data() ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_KHR_create_renderpass2 === | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::createRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 * pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| VULKAN_HPP_NAMESPACE::RenderPass * pRenderPass, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkCreateRenderPass2KHR( m_device, | |
| reinterpret_cast<const VkRenderPassCreateInfo2 *>( pCreateInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), | |
| reinterpret_cast<VkRenderPass *>( pRenderPass ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<VULKAN_HPP_NAMESPACE::RenderPass>::type | |
| Device::createRenderPass2KHR( const RenderPassCreateInfo2 & createInfo, | |
| Optional<const 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.vkCreateRenderPass2KHR( 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::createRenderPass2KHR" ); | |
| } | |
| # 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::createRenderPass2KHRUnique( const RenderPassCreateInfo2 & createInfo, | |
| Optional<const 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.vkCreateRenderPass2KHR( 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::createRenderPass2KHRUnique", deleter ); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::beginRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo * pRenderPassBegin, | |
| const VULKAN_HPP_NAMESPACE::SubpassBeginInfo * pSubpassBeginInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdBeginRenderPass2KHR( m_commandBuffer, | |
| reinterpret_cast<const VkRenderPassBeginInfo *>( pRenderPassBegin ), | |
| reinterpret_cast<const VkSubpassBeginInfo *>( pSubpassBeginInfo ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass2KHR( const RenderPassBeginInfo & renderPassBegin, | |
| const SubpassBeginInfo & subpassBeginInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdBeginRenderPass2KHR( m_commandBuffer, | |
| reinterpret_cast<const VkRenderPassBeginInfo *>( &renderPassBegin ), | |
| reinterpret_cast<const VkSubpassBeginInfo *>( &subpassBeginInfo ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::nextSubpass2KHR( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo * pSubpassBeginInfo, | |
| const VULKAN_HPP_NAMESPACE::SubpassEndInfo * pSubpassEndInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdNextSubpass2KHR( m_commandBuffer, | |
| reinterpret_cast<const VkSubpassBeginInfo *>( pSubpassBeginInfo ), | |
| reinterpret_cast<const VkSubpassEndInfo *>( pSubpassEndInfo ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::nextSubpass2KHR( const SubpassBeginInfo & subpassBeginInfo, | |
| const SubpassEndInfo & subpassEndInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdNextSubpass2KHR( m_commandBuffer, | |
| reinterpret_cast<const VkSubpassBeginInfo *>( &subpassBeginInfo ), | |
| reinterpret_cast<const VkSubpassEndInfo *>( &subpassEndInfo ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::endRenderPass2KHR( const VULKAN_HPP_NAMESPACE::SubpassEndInfo * pSubpassEndInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdEndRenderPass2KHR( m_commandBuffer, reinterpret_cast<const VkSubpassEndInfo *>( pSubpassEndInfo ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::endRenderPass2KHR( const SubpassEndInfo & subpassEndInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdEndRenderPass2KHR( m_commandBuffer, reinterpret_cast<const VkSubpassEndInfo *>( &subpassEndInfo ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_KHR_shared_presentable_image === | |
| #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSwapchainStatusKHR( | |
| VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkGetSwapchainStatusKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ) ) ); | |
| } | |
| #else | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::getSwapchainStatusKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| Result result = | |
| static_cast<Result>( d.vkGetSwapchainStatusKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ) ) ); | |
| return createResultValue( | |
| result, | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::getSwapchainStatusKHR", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR } ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_KHR_external_fence_capabilities === | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void PhysicalDevice::getExternalFencePropertiesKHR( | |
| const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo * pExternalFenceInfo, | |
| VULKAN_HPP_NAMESPACE::ExternalFenceProperties * pExternalFenceProperties, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkGetPhysicalDeviceExternalFencePropertiesKHR( | |
| m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo *>( pExternalFenceInfo ), | |
| reinterpret_cast<VkExternalFenceProperties *>( pExternalFenceProperties ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalFenceProperties | |
| PhysicalDevice::getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfo & externalFenceInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::ExternalFenceProperties externalFenceProperties; | |
| d.vkGetPhysicalDeviceExternalFencePropertiesKHR( | |
| m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo *>( &externalFenceInfo ), | |
| reinterpret_cast<VkExternalFenceProperties *>( &externalFenceProperties ) ); | |
| return externalFenceProperties; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #if defined( VK_USE_PLATFORM_WIN32_KHR ) | |
| //=== VK_KHR_external_fence_win32 === | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::importFenceWin32HandleKHR( | |
| const VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR * pImportFenceWin32HandleInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkImportFenceWin32HandleKHR( | |
| m_device, reinterpret_cast<const VkImportFenceWin32HandleInfoKHR *>( pImportFenceWin32HandleInfo ) ) ); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| Device::importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| Result result = static_cast<Result>( d.vkImportFenceWin32HandleKHR( | |
| m_device, reinterpret_cast<const VkImportFenceWin32HandleInfoKHR *>( &importFenceWin32HandleInfo ) ) ); | |
| return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::importFenceWin32HandleKHR" ); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::getFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR * pGetWin32HandleInfo, | |
| HANDLE * pHandle, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkGetFenceWin32HandleKHR( | |
| m_device, reinterpret_cast<const VkFenceGetWin32HandleInfoKHR *>( pGetWin32HandleInfo ), pHandle ) ); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<HANDLE>::type | |
| Device::getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| HANDLE handle; | |
| Result result = static_cast<Result>( d.vkGetFenceWin32HandleKHR( | |
| m_device, reinterpret_cast<const VkFenceGetWin32HandleInfoKHR *>( &getWin32HandleInfo ), &handle ) ); | |
| return createResultValue( result, handle, VULKAN_HPP_NAMESPACE_STRING "::Device::getFenceWin32HandleKHR" ); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #endif /*VK_USE_PLATFORM_WIN32_KHR*/ | |
| //=== VK_KHR_external_fence_fd === | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::importFenceFdKHR( const VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR * pImportFenceFdInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkImportFenceFdKHR( m_device, reinterpret_cast<const VkImportFenceFdInfoKHR *>( pImportFenceFdInfo ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| Device::importFenceFdKHR( const ImportFenceFdInfoKHR & importFenceFdInfo, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| Result result = static_cast<Result>( | |
| d.vkImportFenceFdKHR( m_device, reinterpret_cast<const VkImportFenceFdInfoKHR *>( &importFenceFdInfo ) ) ); | |
| return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::importFenceFdKHR" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::getFenceFdKHR( const VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR * pGetFdInfo, | |
| int * pFd, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkGetFenceFdKHR( m_device, reinterpret_cast<const VkFenceGetFdInfoKHR *>( pGetFdInfo ), pFd ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<int>::type | |
| Device::getFenceFdKHR( const FenceGetFdInfoKHR & getFdInfo, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| int fd; | |
| Result result = static_cast<Result>( | |
| d.vkGetFenceFdKHR( m_device, reinterpret_cast<const VkFenceGetFdInfoKHR *>( &getFdInfo ), &fd ) ); | |
| return createResultValue( result, fd, VULKAN_HPP_NAMESPACE_STRING "::Device::getFenceFdKHR" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_KHR_performance_query === | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR( | |
| uint32_t queueFamilyIndex, | |
| uint32_t * pCounterCount, | |
| VULKAN_HPP_NAMESPACE::PerformanceCounterKHR * pCounters, | |
| VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR * pCounterDescriptions, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( | |
| m_physicalDevice, | |
| queueFamilyIndex, | |
| pCounterCount, | |
| reinterpret_cast<VkPerformanceCounterKHR *>( pCounters ), | |
| reinterpret_cast<VkPerformanceCounterDescriptionKHR *>( pCounterDescriptions ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Allocator, typename Dispatch> | |
| VULKAN_HPP_DEPRECATED( "This function is deprecated. Use one of the other flavours of it." ) | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE | |
| typename ResultValueType<std::vector<PerformanceCounterDescriptionKHR, Allocator>>::type | |
| PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR( | |
| uint32_t queueFamilyIndex, | |
| ArrayProxy<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR> const & counters, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<PerformanceCounterDescriptionKHR, Allocator> counterDescriptions; | |
| uint32_t counterCount; | |
| Result result; | |
| do | |
| { | |
| result = static_cast<Result>( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( | |
| m_physicalDevice, | |
| queueFamilyIndex, | |
| counters.size(), | |
| reinterpret_cast<VkPerformanceCounterKHR *>( counters.data() ), | |
| nullptr ) ); | |
| if ( ( result == Result::eSuccess ) && counterCount ) | |
| { | |
| counterDescriptions.resize( counterCount ); | |
| result = static_cast<Result>( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( | |
| m_physicalDevice, | |
| queueFamilyIndex, | |
| counters.size(), | |
| reinterpret_cast<VkPerformanceCounterKHR *>( counters.data() ), | |
| reinterpret_cast<VkPerformanceCounterDescriptionKHR *>( counterDescriptions.data() ) ) ); | |
| } | |
| } while ( result == Result::eIncomplete ); | |
| if ( result == Result::eSuccess ) | |
| { | |
| VULKAN_HPP_ASSERT( counterCount <= counterDescriptions.size() ); | |
| counterDescriptions.resize( counterCount ); | |
| } | |
| return createResultValue( result, | |
| counterDescriptions, | |
| VULKAN_HPP_NAMESPACE_STRING | |
| "::PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR" ); | |
| } | |
| template < | |
| typename Allocator, | |
| typename Dispatch, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, PerformanceCounterDescriptionKHR>::value, int>::type> | |
| VULKAN_HPP_DEPRECATED( "This function is deprecated. Use one of the other flavours of it." ) | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE | |
| typename ResultValueType<std::vector<PerformanceCounterDescriptionKHR, Allocator>>::type | |
| PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR( | |
| uint32_t queueFamilyIndex, | |
| ArrayProxy<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR> const & counters, | |
| Allocator const & vectorAllocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<PerformanceCounterDescriptionKHR, Allocator> counterDescriptions( vectorAllocator ); | |
| uint32_t counterCount; | |
| Result result; | |
| do | |
| { | |
| result = static_cast<Result>( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( | |
| m_physicalDevice, | |
| queueFamilyIndex, | |
| counters.size(), | |
| reinterpret_cast<VkPerformanceCounterKHR *>( counters.data() ), | |
| nullptr ) ); | |
| if ( ( result == Result::eSuccess ) && counterCount ) | |
| { | |
| counterDescriptions.resize( counterCount ); | |
| result = static_cast<Result>( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( | |
| m_physicalDevice, | |
| queueFamilyIndex, | |
| counters.size(), | |
| reinterpret_cast<VkPerformanceCounterKHR *>( counters.data() ), | |
| reinterpret_cast<VkPerformanceCounterDescriptionKHR *>( counterDescriptions.data() ) ) ); | |
| } | |
| } while ( result == Result::eIncomplete ); | |
| if ( result == Result::eSuccess ) | |
| { | |
| VULKAN_HPP_ASSERT( counterCount <= counterDescriptions.size() ); | |
| counterDescriptions.resize( counterCount ); | |
| } | |
| return createResultValue( result, | |
| counterDescriptions, | |
| VULKAN_HPP_NAMESPACE_STRING | |
| "::PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR" ); | |
| } | |
| template <typename PerformanceCounterKHRAllocator, | |
| typename PerformanceCounterDescriptionKHRAllocator, | |
| typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType< | |
| std::pair<std::vector<PerformanceCounterKHR, PerformanceCounterKHRAllocator>, | |
| std::vector<PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator>>>::type | |
| PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::pair<std::vector<PerformanceCounterKHR, PerformanceCounterKHRAllocator>, | |
| std::vector<PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator>> | |
| data; | |
| std::vector<PerformanceCounterKHR, PerformanceCounterKHRAllocator> & counters = data.first; | |
| std::vector<PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator> & counterDescriptions = | |
| data.second; | |
| uint32_t counterCount; | |
| Result result; | |
| do | |
| { | |
| result = static_cast<Result>( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( | |
| m_physicalDevice, queueFamilyIndex, &counterCount, nullptr, nullptr ) ); | |
| if ( ( result == Result::eSuccess ) && counterCount ) | |
| { | |
| counters.resize( counterCount ); | |
| counterDescriptions.resize( counterCount ); | |
| result = static_cast<Result>( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( | |
| m_physicalDevice, | |
| queueFamilyIndex, | |
| &counterCount, | |
| reinterpret_cast<VkPerformanceCounterKHR *>( counters.data() ), | |
| reinterpret_cast<VkPerformanceCounterDescriptionKHR *>( counterDescriptions.data() ) ) ); | |
| VULKAN_HPP_ASSERT( counterCount <= counters.size() ); | |
| } | |
| } while ( result == Result::eIncomplete ); | |
| if ( ( result == Result::eSuccess ) && ( counterCount < counters.size() ) ) | |
| { | |
| counters.resize( counterCount ); | |
| counterDescriptions.resize( counterCount ); | |
| } | |
| return createResultValue( | |
| result, data, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR" ); | |
| } | |
| template <typename PerformanceCounterKHRAllocator, | |
| typename PerformanceCounterDescriptionKHRAllocator, | |
| typename Dispatch, | |
| typename B1, | |
| typename B2, | |
| typename std::enable_if<std::is_same<typename B1::value_type, PerformanceCounterKHR>::value && | |
| std::is_same<typename B2::value_type, PerformanceCounterDescriptionKHR>::value, | |
| int>::type> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType< | |
| std::pair<std::vector<PerformanceCounterKHR, PerformanceCounterKHRAllocator>, | |
| std::vector<PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator>>>::type | |
| PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR( | |
| uint32_t queueFamilyIndex, | |
| PerformanceCounterKHRAllocator & performanceCounterKHRAllocator, | |
| PerformanceCounterDescriptionKHRAllocator & performanceCounterDescriptionKHRAllocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::pair<std::vector<PerformanceCounterKHR, PerformanceCounterKHRAllocator>, | |
| std::vector<PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator>> | |
| data( std::piecewise_construct, | |
| std::forward_as_tuple( performanceCounterKHRAllocator ), | |
| std::forward_as_tuple( performanceCounterDescriptionKHRAllocator ) ); | |
| std::vector<PerformanceCounterKHR, PerformanceCounterKHRAllocator> & counters = data.first; | |
| std::vector<PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator> & counterDescriptions = | |
| data.second; | |
| uint32_t counterCount; | |
| Result result; | |
| do | |
| { | |
| result = static_cast<Result>( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( | |
| m_physicalDevice, queueFamilyIndex, &counterCount, nullptr, nullptr ) ); | |
| if ( ( result == Result::eSuccess ) && counterCount ) | |
| { | |
| counters.resize( counterCount ); | |
| counterDescriptions.resize( counterCount ); | |
| result = static_cast<Result>( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( | |
| m_physicalDevice, | |
| queueFamilyIndex, | |
| &counterCount, | |
| reinterpret_cast<VkPerformanceCounterKHR *>( counters.data() ), | |
| reinterpret_cast<VkPerformanceCounterDescriptionKHR *>( counterDescriptions.data() ) ) ); | |
| VULKAN_HPP_ASSERT( counterCount <= counters.size() ); | |
| } | |
| } while ( result == Result::eIncomplete ); | |
| if ( ( result == Result::eSuccess ) && ( counterCount < counters.size() ) ) | |
| { | |
| counters.resize( counterCount ); | |
| counterDescriptions.resize( counterCount ); | |
| } | |
| return createResultValue( | |
| result, data, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void PhysicalDevice::getQueueFamilyPerformanceQueryPassesKHR( | |
| const VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR * pPerformanceQueryCreateInfo, | |
| uint32_t * pNumPasses, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( | |
| m_physicalDevice, | |
| reinterpret_cast<const VkQueryPoolPerformanceCreateInfoKHR *>( pPerformanceQueryCreateInfo ), | |
| pNumPasses ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint32_t PhysicalDevice::getQueueFamilyPerformanceQueryPassesKHR( | |
| const QueryPoolPerformanceCreateInfoKHR & performanceQueryCreateInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| uint32_t numPasses; | |
| d.vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( | |
| m_physicalDevice, | |
| reinterpret_cast<const VkQueryPoolPerformanceCreateInfoKHR *>( &performanceQueryCreateInfo ), | |
| &numPasses ); | |
| return numPasses; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::acquireProfilingLockKHR( | |
| const VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR * pInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkAcquireProfilingLockKHR( m_device, reinterpret_cast<const VkAcquireProfilingLockInfoKHR *>( pInfo ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| Device::acquireProfilingLockKHR( const AcquireProfilingLockInfoKHR & info, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| Result result = static_cast<Result>( | |
| d.vkAcquireProfilingLockKHR( m_device, reinterpret_cast<const VkAcquireProfilingLockInfoKHR *>( &info ) ) ); | |
| return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::acquireProfilingLockKHR" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::releaseProfilingLockKHR( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkReleaseProfilingLockKHR( m_device ); | |
| } | |
| //=== VK_KHR_get_surface_capabilities2 === | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceCapabilities2KHR( | |
| const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo, | |
| VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR * pSurfaceCapabilities, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilities2KHR( | |
| m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( pSurfaceInfo ), | |
| reinterpret_cast<VkSurfaceCapabilities2KHR *>( pSurfaceCapabilities ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR>::type | |
| PhysicalDevice::getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR surfaceCapabilities; | |
| Result result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilities2KHR( | |
| m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ), | |
| reinterpret_cast<VkSurfaceCapabilities2KHR *>( &surfaceCapabilities ) ) ); | |
| return createResultValue( | |
| result, surfaceCapabilities, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilities2KHR" ); | |
| } | |
| 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::getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| StructureChain<X, Y, Z...> structureChain; | |
| VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR & surfaceCapabilities = | |
| structureChain.template get<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR>(); | |
| Result result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilities2KHR( | |
| m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ), | |
| reinterpret_cast<VkSurfaceCapabilities2KHR *>( &surfaceCapabilities ) ) ); | |
| return createResultValue( | |
| result, structureChain, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilities2KHR" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| PhysicalDevice::getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo, | |
| uint32_t * pSurfaceFormatCount, | |
| VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR * pSurfaceFormats, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormats2KHR( | |
| m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( pSurfaceInfo ), | |
| pSurfaceFormatCount, | |
| reinterpret_cast<VkSurfaceFormat2KHR *>( pSurfaceFormats ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename SurfaceFormat2KHRAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE | |
| typename ResultValueType<std::vector<SurfaceFormat2KHR, SurfaceFormat2KHRAllocator>>::type | |
| PhysicalDevice::getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<SurfaceFormat2KHR, SurfaceFormat2KHRAllocator> surfaceFormats; | |
| uint32_t surfaceFormatCount; | |
| Result result; | |
| do | |
| { | |
| result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormats2KHR( | |
| m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ), | |
| &surfaceFormatCount, | |
| nullptr ) ); | |
| if ( ( result == Result::eSuccess ) && surfaceFormatCount ) | |
| { | |
| surfaceFormats.resize( surfaceFormatCount ); | |
| result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormats2KHR( | |
| m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ), | |
| &surfaceFormatCount, | |
| reinterpret_cast<VkSurfaceFormat2KHR *>( 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::getSurfaceFormats2KHR" ); | |
| } | |
| template <typename SurfaceFormat2KHRAllocator, | |
| typename Dispatch, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, SurfaceFormat2KHR>::value, int>::type> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE | |
| typename ResultValueType<std::vector<SurfaceFormat2KHR, SurfaceFormat2KHRAllocator>>::type | |
| PhysicalDevice::getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, | |
| SurfaceFormat2KHRAllocator & surfaceFormat2KHRAllocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<SurfaceFormat2KHR, SurfaceFormat2KHRAllocator> surfaceFormats( surfaceFormat2KHRAllocator ); | |
| uint32_t surfaceFormatCount; | |
| Result result; | |
| do | |
| { | |
| result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormats2KHR( | |
| m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ), | |
| &surfaceFormatCount, | |
| nullptr ) ); | |
| if ( ( result == Result::eSuccess ) && surfaceFormatCount ) | |
| { | |
| surfaceFormats.resize( surfaceFormatCount ); | |
| result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormats2KHR( | |
| m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ), | |
| &surfaceFormatCount, | |
| reinterpret_cast<VkSurfaceFormat2KHR *>( 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::getSurfaceFormats2KHR" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_KHR_get_display_properties2 === | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| PhysicalDevice::getDisplayProperties2KHR( uint32_t * pPropertyCount, | |
| VULKAN_HPP_NAMESPACE::DisplayProperties2KHR * pProperties, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkGetPhysicalDeviceDisplayProperties2KHR( | |
| m_physicalDevice, pPropertyCount, reinterpret_cast<VkDisplayProperties2KHR *>( pProperties ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename DisplayProperties2KHRAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE | |
| typename ResultValueType<std::vector<DisplayProperties2KHR, DisplayProperties2KHRAllocator>>::type | |
| PhysicalDevice::getDisplayProperties2KHR( Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<DisplayProperties2KHR, DisplayProperties2KHRAllocator> properties; | |
| uint32_t propertyCount; | |
| Result result; | |
| do | |
| { | |
| result = | |
| static_cast<Result>( d.vkGetPhysicalDeviceDisplayProperties2KHR( m_physicalDevice, &propertyCount, nullptr ) ); | |
| if ( ( result == Result::eSuccess ) && propertyCount ) | |
| { | |
| properties.resize( propertyCount ); | |
| result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayProperties2KHR( | |
| m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayProperties2KHR *>( 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::getDisplayProperties2KHR" ); | |
| } | |
| template <typename DisplayProperties2KHRAllocator, | |
| typename Dispatch, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, DisplayProperties2KHR>::value, int>::type> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE | |
| typename ResultValueType<std::vector<DisplayProperties2KHR, DisplayProperties2KHRAllocator>>::type | |
| PhysicalDevice::getDisplayProperties2KHR( DisplayProperties2KHRAllocator & displayProperties2KHRAllocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<DisplayProperties2KHR, DisplayProperties2KHRAllocator> properties( displayProperties2KHRAllocator ); | |
| uint32_t propertyCount; | |
| Result result; | |
| do | |
| { | |
| result = | |
| static_cast<Result>( d.vkGetPhysicalDeviceDisplayProperties2KHR( m_physicalDevice, &propertyCount, nullptr ) ); | |
| if ( ( result == Result::eSuccess ) && propertyCount ) | |
| { | |
| properties.resize( propertyCount ); | |
| result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayProperties2KHR( | |
| m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayProperties2KHR *>( 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::getDisplayProperties2KHR" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| PhysicalDevice::getDisplayPlaneProperties2KHR( uint32_t * pPropertyCount, | |
| VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR * pProperties, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR( | |
| m_physicalDevice, pPropertyCount, reinterpret_cast<VkDisplayPlaneProperties2KHR *>( pProperties ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename DisplayPlaneProperties2KHRAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE | |
| typename ResultValueType<std::vector<DisplayPlaneProperties2KHR, DisplayPlaneProperties2KHRAllocator>>::type | |
| PhysicalDevice::getDisplayPlaneProperties2KHR( Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<DisplayPlaneProperties2KHR, DisplayPlaneProperties2KHRAllocator> properties; | |
| uint32_t propertyCount; | |
| Result result; | |
| do | |
| { | |
| result = static_cast<Result>( | |
| d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR( m_physicalDevice, &propertyCount, nullptr ) ); | |
| if ( ( result == Result::eSuccess ) && propertyCount ) | |
| { | |
| properties.resize( propertyCount ); | |
| result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR( | |
| m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayPlaneProperties2KHR *>( 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::getDisplayPlaneProperties2KHR" ); | |
| } | |
| template <typename DisplayPlaneProperties2KHRAllocator, | |
| typename Dispatch, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, DisplayPlaneProperties2KHR>::value, int>::type> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE | |
| typename ResultValueType<std::vector<DisplayPlaneProperties2KHR, DisplayPlaneProperties2KHRAllocator>>::type | |
| PhysicalDevice::getDisplayPlaneProperties2KHR( | |
| DisplayPlaneProperties2KHRAllocator & displayPlaneProperties2KHRAllocator, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<DisplayPlaneProperties2KHR, DisplayPlaneProperties2KHRAllocator> properties( | |
| displayPlaneProperties2KHRAllocator ); | |
| uint32_t propertyCount; | |
| Result result; | |
| do | |
| { | |
| result = static_cast<Result>( | |
| d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR( m_physicalDevice, &propertyCount, nullptr ) ); | |
| if ( ( result == Result::eSuccess ) && propertyCount ) | |
| { | |
| properties.resize( propertyCount ); | |
| result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR( | |
| m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayPlaneProperties2KHR *>( 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::getDisplayPlaneProperties2KHR" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| PhysicalDevice::getDisplayModeProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, | |
| uint32_t * pPropertyCount, | |
| VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR * pProperties, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkGetDisplayModeProperties2KHR( m_physicalDevice, | |
| static_cast<VkDisplayKHR>( display ), | |
| pPropertyCount, | |
| reinterpret_cast<VkDisplayModeProperties2KHR *>( pProperties ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename DisplayModeProperties2KHRAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE | |
| typename ResultValueType<std::vector<DisplayModeProperties2KHR, DisplayModeProperties2KHRAllocator>>::type | |
| PhysicalDevice::getDisplayModeProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<DisplayModeProperties2KHR, DisplayModeProperties2KHRAllocator> properties; | |
| uint32_t propertyCount; | |
| Result result; | |
| do | |
| { | |
| result = static_cast<Result>( d.vkGetDisplayModeProperties2KHR( | |
| m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, nullptr ) ); | |
| if ( ( result == Result::eSuccess ) && propertyCount ) | |
| { | |
| properties.resize( propertyCount ); | |
| result = static_cast<Result>( | |
| d.vkGetDisplayModeProperties2KHR( m_physicalDevice, | |
| static_cast<VkDisplayKHR>( display ), | |
| &propertyCount, | |
| reinterpret_cast<VkDisplayModeProperties2KHR *>( 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::getDisplayModeProperties2KHR" ); | |
| } | |
| template <typename DisplayModeProperties2KHRAllocator, | |
| typename Dispatch, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, DisplayModeProperties2KHR>::value, int>::type> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE | |
| typename ResultValueType<std::vector<DisplayModeProperties2KHR, DisplayModeProperties2KHRAllocator>>::type | |
| PhysicalDevice::getDisplayModeProperties2KHR( | |
| VULKAN_HPP_NAMESPACE::DisplayKHR display, | |
| DisplayModeProperties2KHRAllocator & displayModeProperties2KHRAllocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<DisplayModeProperties2KHR, DisplayModeProperties2KHRAllocator> properties( | |
| displayModeProperties2KHRAllocator ); | |
| uint32_t propertyCount; | |
| Result result; | |
| do | |
| { | |
| result = static_cast<Result>( d.vkGetDisplayModeProperties2KHR( | |
| m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, nullptr ) ); | |
| if ( ( result == Result::eSuccess ) && propertyCount ) | |
| { | |
| properties.resize( propertyCount ); | |
| result = static_cast<Result>( | |
| d.vkGetDisplayModeProperties2KHR( m_physicalDevice, | |
| static_cast<VkDisplayKHR>( display ), | |
| &propertyCount, | |
| reinterpret_cast<VkDisplayModeProperties2KHR *>( 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::getDisplayModeProperties2KHR" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlaneCapabilities2KHR( | |
| const VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR * pDisplayPlaneInfo, | |
| VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR * pCapabilities, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkGetDisplayPlaneCapabilities2KHR( m_physicalDevice, | |
| reinterpret_cast<const VkDisplayPlaneInfo2KHR *>( pDisplayPlaneInfo ), | |
| reinterpret_cast<VkDisplayPlaneCapabilities2KHR *>( pCapabilities ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR>::type | |
| PhysicalDevice::getDisplayPlaneCapabilities2KHR( const DisplayPlaneInfo2KHR & displayPlaneInfo, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR capabilities; | |
| Result result = static_cast<Result>( | |
| d.vkGetDisplayPlaneCapabilities2KHR( m_physicalDevice, | |
| reinterpret_cast<const VkDisplayPlaneInfo2KHR *>( &displayPlaneInfo ), | |
| reinterpret_cast<VkDisplayPlaneCapabilities2KHR *>( &capabilities ) ) ); | |
| return createResultValue( | |
| result, capabilities, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneCapabilities2KHR" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #if defined( VK_USE_PLATFORM_IOS_MVK ) | |
| //=== VK_MVK_ios_surface === | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Instance::createIOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK * pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkCreateIOSSurfaceMVK( m_instance, | |
| reinterpret_cast<const VkIOSSurfaceCreateInfoMVK *>( pCreateInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), | |
| reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) ); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type | |
| Instance::createIOSSurfaceMVK( const IOSSurfaceCreateInfoMVK & createInfo, | |
| Optional<const 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.vkCreateIOSSurfaceMVK( m_instance, | |
| reinterpret_cast<const VkIOSSurfaceCreateInfoMVK *>( &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::createIOSSurfaceMVK" ); | |
| } | |
| # 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::createIOSSurfaceMVKUnique( const IOSSurfaceCreateInfoMVK & createInfo, | |
| Optional<const 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.vkCreateIOSSurfaceMVK( m_instance, | |
| reinterpret_cast<const VkIOSSurfaceCreateInfoMVK *>( &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::createIOSSurfaceMVKUnique", deleter ); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #endif /*VK_USE_PLATFORM_IOS_MVK*/ | |
| #if defined( VK_USE_PLATFORM_MACOS_MVK ) | |
| //=== VK_MVK_macos_surface === | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Instance::createMacOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK * pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkCreateMacOSSurfaceMVK( m_instance, | |
| reinterpret_cast<const VkMacOSSurfaceCreateInfoMVK *>( pCreateInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), | |
| reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) ); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type | |
| Instance::createMacOSSurfaceMVK( const MacOSSurfaceCreateInfoMVK & createInfo, | |
| Optional<const 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.vkCreateMacOSSurfaceMVK( m_instance, | |
| reinterpret_cast<const VkMacOSSurfaceCreateInfoMVK *>( &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::createMacOSSurfaceMVK" ); | |
| } | |
| # 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::createMacOSSurfaceMVKUnique( const MacOSSurfaceCreateInfoMVK & createInfo, | |
| Optional<const 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.vkCreateMacOSSurfaceMVK( m_instance, | |
| reinterpret_cast<const VkMacOSSurfaceCreateInfoMVK *>( &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::createMacOSSurfaceMVKUnique", deleter ); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #endif /*VK_USE_PLATFORM_MACOS_MVK*/ | |
| //=== VK_EXT_debug_utils === | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::setDebugUtilsObjectNameEXT( | |
| const VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT * pNameInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkSetDebugUtilsObjectNameEXT( | |
| m_device, reinterpret_cast<const VkDebugUtilsObjectNameInfoEXT *>( pNameInfo ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| Device::setDebugUtilsObjectNameEXT( const DebugUtilsObjectNameInfoEXT & nameInfo, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| Result result = static_cast<Result>( d.vkSetDebugUtilsObjectNameEXT( | |
| m_device, reinterpret_cast<const VkDebugUtilsObjectNameInfoEXT *>( &nameInfo ) ) ); | |
| return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setDebugUtilsObjectNameEXT" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::setDebugUtilsObjectTagEXT( | |
| const VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT * pTagInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkSetDebugUtilsObjectTagEXT( m_device, reinterpret_cast<const VkDebugUtilsObjectTagInfoEXT *>( pTagInfo ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| Device::setDebugUtilsObjectTagEXT( const DebugUtilsObjectTagInfoEXT & tagInfo, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| Result result = static_cast<Result>( | |
| d.vkSetDebugUtilsObjectTagEXT( m_device, reinterpret_cast<const VkDebugUtilsObjectTagInfoEXT *>( &tagInfo ) ) ); | |
| return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setDebugUtilsObjectTagEXT" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Queue::beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkQueueBeginDebugUtilsLabelEXT( m_queue, reinterpret_cast<const VkDebugUtilsLabelEXT *>( pLabelInfo ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Queue::beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkQueueBeginDebugUtilsLabelEXT( m_queue, reinterpret_cast<const VkDebugUtilsLabelEXT *>( &labelInfo ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Queue::endDebugUtilsLabelEXT( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkQueueEndDebugUtilsLabelEXT( m_queue ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Queue::insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkQueueInsertDebugUtilsLabelEXT( m_queue, reinterpret_cast<const VkDebugUtilsLabelEXT *>( pLabelInfo ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Queue::insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkQueueInsertDebugUtilsLabelEXT( m_queue, reinterpret_cast<const VkDebugUtilsLabelEXT *>( &labelInfo ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdBeginDebugUtilsLabelEXT( m_commandBuffer, reinterpret_cast<const VkDebugUtilsLabelEXT *>( pLabelInfo ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdBeginDebugUtilsLabelEXT( m_commandBuffer, reinterpret_cast<const VkDebugUtilsLabelEXT *>( &labelInfo ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::endDebugUtilsLabelEXT( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdEndDebugUtilsLabelEXT( m_commandBuffer ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdInsertDebugUtilsLabelEXT( m_commandBuffer, reinterpret_cast<const VkDebugUtilsLabelEXT *>( pLabelInfo ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdInsertDebugUtilsLabelEXT( m_commandBuffer, reinterpret_cast<const VkDebugUtilsLabelEXT *>( &labelInfo ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Instance::createDebugUtilsMessengerEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT * pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT * pMessenger, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkCreateDebugUtilsMessengerEXT( m_instance, | |
| reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT *>( pCreateInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), | |
| reinterpret_cast<VkDebugUtilsMessengerEXT *>( pMessenger ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT>::type | |
| Instance::createDebugUtilsMessengerEXT( const DebugUtilsMessengerCreateInfoEXT & createInfo, | |
| Optional<const AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger; | |
| Result result = static_cast<Result>( | |
| d.vkCreateDebugUtilsMessengerEXT( m_instance, | |
| reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkDebugUtilsMessengerEXT *>( &messenger ) ) ); | |
| return createResultValue( | |
| result, messenger, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDebugUtilsMessengerEXT" ); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT, Dispatch>>::type | |
| Instance::createDebugUtilsMessengerEXTUnique( const DebugUtilsMessengerCreateInfoEXT & createInfo, | |
| Optional<const AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger; | |
| Result result = static_cast<Result>( | |
| d.vkCreateDebugUtilsMessengerEXT( m_instance, | |
| reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkDebugUtilsMessengerEXT *>( &messenger ) ) ); | |
| ObjectDestroy<Instance, Dispatch> deleter( *this, allocator, d ); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT, Dispatch>( | |
| result, messenger, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDebugUtilsMessengerEXTUnique", deleter ); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| Instance::destroyDebugUtilsMessengerEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyDebugUtilsMessengerEXT( m_instance, | |
| static_cast<VkDebugUtilsMessengerEXT>( messenger ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| Instance::destroyDebugUtilsMessengerEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger, | |
| Optional<const AllocationCallbacks> allocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyDebugUtilsMessengerEXT( | |
| m_instance, | |
| static_cast<VkDebugUtilsMessengerEXT>( messenger ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Instance::destroy( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyDebugUtilsMessengerEXT( m_instance, | |
| static_cast<VkDebugUtilsMessengerEXT>( messenger ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Instance::destroy( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger, | |
| Optional<const AllocationCallbacks> allocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyDebugUtilsMessengerEXT( | |
| m_instance, | |
| static_cast<VkDebugUtilsMessengerEXT>( messenger ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Instance::submitDebugUtilsMessageEXT( | |
| VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, | |
| VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT messageTypes, | |
| const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT * pCallbackData, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkSubmitDebugUtilsMessageEXT( m_instance, | |
| static_cast<VkDebugUtilsMessageSeverityFlagBitsEXT>( messageSeverity ), | |
| static_cast<VkDebugUtilsMessageTypeFlagsEXT>( messageTypes ), | |
| reinterpret_cast<const VkDebugUtilsMessengerCallbackDataEXT *>( pCallbackData ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| Instance::submitDebugUtilsMessageEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, | |
| VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT messageTypes, | |
| const DebugUtilsMessengerCallbackDataEXT & callbackData, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkSubmitDebugUtilsMessageEXT( m_instance, | |
| static_cast<VkDebugUtilsMessageSeverityFlagBitsEXT>( messageSeverity ), | |
| static_cast<VkDebugUtilsMessageTypeFlagsEXT>( messageTypes ), | |
| reinterpret_cast<const VkDebugUtilsMessengerCallbackDataEXT *>( &callbackData ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #if defined( VK_USE_PLATFORM_ANDROID_KHR ) | |
| //=== VK_ANDROID_external_memory_android_hardware_buffer === | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getAndroidHardwareBufferPropertiesANDROID( | |
| const struct AHardwareBuffer * buffer, | |
| VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID * pProperties, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkGetAndroidHardwareBufferPropertiesANDROID( | |
| m_device, buffer, reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID *>( pProperties ) ) ); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID>::type | |
| Device::getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID properties; | |
| Result result = static_cast<Result>( d.vkGetAndroidHardwareBufferPropertiesANDROID( | |
| m_device, &buffer, reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID *>( &properties ) ) ); | |
| return createResultValue( | |
| result, properties, VULKAN_HPP_NAMESPACE_STRING "::Device::getAndroidHardwareBufferPropertiesANDROID" ); | |
| } | |
| 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 | |
| Device::getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| StructureChain<X, Y, Z...> structureChain; | |
| VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID & properties = | |
| structureChain.template get<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID>(); | |
| Result result = static_cast<Result>( d.vkGetAndroidHardwareBufferPropertiesANDROID( | |
| m_device, &buffer, reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID *>( &properties ) ) ); | |
| return createResultValue( | |
| result, structureChain, VULKAN_HPP_NAMESPACE_STRING "::Device::getAndroidHardwareBufferPropertiesANDROID" ); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getMemoryAndroidHardwareBufferANDROID( | |
| const VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID * pInfo, | |
| struct AHardwareBuffer ** pBuffer, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkGetMemoryAndroidHardwareBufferANDROID( | |
| m_device, reinterpret_cast<const VkMemoryGetAndroidHardwareBufferInfoANDROID *>( pInfo ), pBuffer ) ); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<struct AHardwareBuffer *>::type | |
| Device::getMemoryAndroidHardwareBufferANDROID( const MemoryGetAndroidHardwareBufferInfoANDROID & info, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| struct AHardwareBuffer * buffer; | |
| Result result = static_cast<Result>( d.vkGetMemoryAndroidHardwareBufferANDROID( | |
| m_device, reinterpret_cast<const VkMemoryGetAndroidHardwareBufferInfoANDROID *>( &info ), &buffer ) ); | |
| return createResultValue( | |
| result, buffer, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryAndroidHardwareBufferANDROID" ); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ | |
| //=== VK_EXT_sample_locations === | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::setSampleLocationsEXT( const VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT * pSampleLocationsInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdSetSampleLocationsEXT( m_commandBuffer, | |
| reinterpret_cast<const VkSampleLocationsInfoEXT *>( pSampleLocationsInfo ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setSampleLocationsEXT( const SampleLocationsInfoEXT & sampleLocationsInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdSetSampleLocationsEXT( m_commandBuffer, | |
| reinterpret_cast<const VkSampleLocationsInfoEXT *>( &sampleLocationsInfo ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void PhysicalDevice::getMultisamplePropertiesEXT( | |
| VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples, | |
| VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT * pMultisampleProperties, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkGetPhysicalDeviceMultisamplePropertiesEXT( | |
| m_physicalDevice, | |
| static_cast<VkSampleCountFlagBits>( samples ), | |
| reinterpret_cast<VkMultisamplePropertiesEXT *>( pMultisampleProperties ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT | |
| PhysicalDevice::getMultisamplePropertiesEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT multisampleProperties; | |
| d.vkGetPhysicalDeviceMultisamplePropertiesEXT( | |
| m_physicalDevice, | |
| static_cast<VkSampleCountFlagBits>( samples ), | |
| reinterpret_cast<VkMultisamplePropertiesEXT *>( &multisampleProperties ) ); | |
| return multisampleProperties; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_KHR_get_memory_requirements2 === | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| Device::getImageMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 * pInfo, | |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkGetImageMemoryRequirements2KHR( m_device, | |
| reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>( pInfo ), | |
| reinterpret_cast<VkMemoryRequirements2 *>( pMemoryRequirements ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2 | |
| Device::getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements; | |
| d.vkGetImageMemoryRequirements2KHR( m_device, | |
| reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>( &info ), | |
| reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) ); | |
| return memoryRequirements; | |
| } | |
| template <typename X, typename Y, typename... Z, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> | |
| Device::getImageMemoryRequirements2KHR( const 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.vkGetImageMemoryRequirements2KHR( m_device, | |
| reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>( &info ), | |
| reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) ); | |
| return structureChain; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| Device::getBufferMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 * pInfo, | |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkGetBufferMemoryRequirements2KHR( m_device, | |
| reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>( pInfo ), | |
| reinterpret_cast<VkMemoryRequirements2 *>( pMemoryRequirements ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2 | |
| Device::getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements; | |
| d.vkGetBufferMemoryRequirements2KHR( m_device, | |
| reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>( &info ), | |
| reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) ); | |
| return memoryRequirements; | |
| } | |
| template <typename X, typename Y, typename... Z, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> | |
| Device::getBufferMemoryRequirements2KHR( const 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.vkGetBufferMemoryRequirements2KHR( m_device, | |
| reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>( &info ), | |
| reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) ); | |
| return structureChain; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirements2KHR( | |
| const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 * pInfo, | |
| uint32_t * pSparseMemoryRequirementCount, | |
| VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 * pSparseMemoryRequirements, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkGetImageSparseMemoryRequirements2KHR( | |
| m_device, | |
| reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( pInfo ), | |
| pSparseMemoryRequirementCount, | |
| reinterpret_cast<VkSparseImageMemoryRequirements2 *>( pSparseMemoryRequirements ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename SparseImageMemoryRequirements2Allocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD | |
| VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> | |
| Device::getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> sparseMemoryRequirements; | |
| uint32_t sparseMemoryRequirementCount; | |
| d.vkGetImageSparseMemoryRequirements2KHR( m_device, | |
| reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ), | |
| &sparseMemoryRequirementCount, | |
| nullptr ); | |
| sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); | |
| d.vkGetImageSparseMemoryRequirements2KHR( | |
| m_device, | |
| reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ), | |
| &sparseMemoryRequirementCount, | |
| reinterpret_cast<VkSparseImageMemoryRequirements2 *>( sparseMemoryRequirements.data() ) ); | |
| VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() ); | |
| 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::getImageSparseMemoryRequirements2KHR( | |
| const 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.vkGetImageSparseMemoryRequirements2KHR( m_device, | |
| reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ), | |
| &sparseMemoryRequirementCount, | |
| nullptr ); | |
| sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); | |
| d.vkGetImageSparseMemoryRequirements2KHR( | |
| m_device, | |
| reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ), | |
| &sparseMemoryRequirementCount, | |
| reinterpret_cast<VkSparseImageMemoryRequirements2 *>( sparseMemoryRequirements.data() ) ); | |
| VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() ); | |
| return sparseMemoryRequirements; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_KHR_acceleration_structure === | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createAccelerationStructureKHR( | |
| const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR * pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| VULKAN_HPP_NAMESPACE::AccelerationStructureKHR * pAccelerationStructure, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkCreateAccelerationStructureKHR( m_device, | |
| reinterpret_cast<const VkAccelerationStructureCreateInfoKHR *>( pCreateInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), | |
| reinterpret_cast<VkAccelerationStructureKHR *>( pAccelerationStructure ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR>::type | |
| Device::createAccelerationStructureKHR( const AccelerationStructureCreateInfoKHR & createInfo, | |
| Optional<const AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure; | |
| Result result = static_cast<Result>( d.vkCreateAccelerationStructureKHR( | |
| m_device, | |
| reinterpret_cast<const VkAccelerationStructureCreateInfoKHR *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkAccelerationStructureKHR *>( &accelerationStructure ) ) ); | |
| return createResultValue( | |
| result, accelerationStructure, VULKAN_HPP_NAMESPACE_STRING "::Device::createAccelerationStructureKHR" ); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR, Dispatch>>::type | |
| Device::createAccelerationStructureKHRUnique( const AccelerationStructureCreateInfoKHR & createInfo, | |
| Optional<const AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure; | |
| Result result = static_cast<Result>( d.vkCreateAccelerationStructureKHR( | |
| m_device, | |
| reinterpret_cast<const VkAccelerationStructureCreateInfoKHR *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkAccelerationStructureKHR *>( &accelerationStructure ) ) ); | |
| ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d ); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR, Dispatch>( | |
| result, | |
| accelerationStructure, | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createAccelerationStructureKHRUnique", | |
| deleter ); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| Device::destroyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyAccelerationStructureKHR( m_device, | |
| static_cast<VkAccelerationStructureKHR>( accelerationStructure ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| Device::destroyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure, | |
| Optional<const AllocationCallbacks> allocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyAccelerationStructureKHR( | |
| m_device, | |
| static_cast<VkAccelerationStructureKHR>( accelerationStructure ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyAccelerationStructureKHR( m_device, | |
| static_cast<VkAccelerationStructureKHR>( accelerationStructure ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure, | |
| Optional<const AllocationCallbacks> allocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyAccelerationStructureKHR( | |
| m_device, | |
| static_cast<VkAccelerationStructureKHR>( accelerationStructure ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructuresKHR( | |
| uint32_t infoCount, | |
| const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR * pInfos, | |
| const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdBuildAccelerationStructuresKHR( | |
| m_commandBuffer, | |
| infoCount, | |
| reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>( pInfos ), | |
| reinterpret_cast<const VkAccelerationStructureBuildRangeInfoKHR * const *>( ppBuildRangeInfos ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructuresKHR( | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const> const & pBuildRangeInfos, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| # ifdef VULKAN_HPP_NO_EXCEPTIONS | |
| VULKAN_HPP_ASSERT( infos.size() == pBuildRangeInfos.size() ); | |
| # else | |
| if ( infos.size() != pBuildRangeInfos.size() ) | |
| { | |
| throw LogicError( VULKAN_HPP_NAMESPACE_STRING | |
| "::CommandBuffer::buildAccelerationStructuresKHR: infos.size() != pBuildRangeInfos.size()" ); | |
| } | |
| # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ | |
| d.vkCmdBuildAccelerationStructuresKHR( | |
| m_commandBuffer, | |
| infos.size(), | |
| reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>( infos.data() ), | |
| reinterpret_cast<const VkAccelerationStructureBuildRangeInfoKHR * const *>( pBuildRangeInfos.data() ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructuresIndirectKHR( | |
| uint32_t infoCount, | |
| const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR * pInfos, | |
| const VULKAN_HPP_NAMESPACE::DeviceAddress * pIndirectDeviceAddresses, | |
| const uint32_t * pIndirectStrides, | |
| const uint32_t * const * ppMaxPrimitiveCounts, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdBuildAccelerationStructuresIndirectKHR( | |
| m_commandBuffer, | |
| infoCount, | |
| reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>( pInfos ), | |
| reinterpret_cast<const VkDeviceAddress *>( pIndirectDeviceAddresses ), | |
| pIndirectStrides, | |
| ppMaxPrimitiveCounts ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructuresIndirectKHR( | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceAddress> const & indirectDeviceAddresses, | |
| ArrayProxy<const uint32_t> const & indirectStrides, | |
| ArrayProxy<const uint32_t * const> const & pMaxPrimitiveCounts, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| # ifdef VULKAN_HPP_NO_EXCEPTIONS | |
| VULKAN_HPP_ASSERT( infos.size() == indirectDeviceAddresses.size() ); | |
| VULKAN_HPP_ASSERT( infos.size() == indirectStrides.size() ); | |
| VULKAN_HPP_ASSERT( infos.size() == pMaxPrimitiveCounts.size() ); | |
| # else | |
| if ( infos.size() != indirectDeviceAddresses.size() ) | |
| { | |
| throw LogicError( | |
| VULKAN_HPP_NAMESPACE_STRING | |
| "::CommandBuffer::buildAccelerationStructuresIndirectKHR: infos.size() != indirectDeviceAddresses.size()" ); | |
| } | |
| if ( infos.size() != indirectStrides.size() ) | |
| { | |
| throw LogicError( | |
| VULKAN_HPP_NAMESPACE_STRING | |
| "::CommandBuffer::buildAccelerationStructuresIndirectKHR: infos.size() != indirectStrides.size()" ); | |
| } | |
| if ( infos.size() != pMaxPrimitiveCounts.size() ) | |
| { | |
| throw LogicError( | |
| VULKAN_HPP_NAMESPACE_STRING | |
| "::CommandBuffer::buildAccelerationStructuresIndirectKHR: infos.size() != pMaxPrimitiveCounts.size()" ); | |
| } | |
| # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ | |
| d.vkCmdBuildAccelerationStructuresIndirectKHR( | |
| m_commandBuffer, | |
| infos.size(), | |
| reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>( infos.data() ), | |
| reinterpret_cast<const VkDeviceAddress *>( indirectDeviceAddresses.data() ), | |
| indirectStrides.data(), | |
| pMaxPrimitiveCounts.data() ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::buildAccelerationStructuresKHR( | |
| VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, | |
| uint32_t infoCount, | |
| const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR * pInfos, | |
| const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkBuildAccelerationStructuresKHR( | |
| m_device, | |
| static_cast<VkDeferredOperationKHR>( deferredOperation ), | |
| infoCount, | |
| reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>( pInfos ), | |
| reinterpret_cast<const VkAccelerationStructureBuildRangeInfoKHR * const *>( ppBuildRangeInfos ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE Result Device::buildAccelerationStructuresKHR( | |
| VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const> const & pBuildRangeInfos, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| # ifdef VULKAN_HPP_NO_EXCEPTIONS | |
| VULKAN_HPP_ASSERT( infos.size() == pBuildRangeInfos.size() ); | |
| # else | |
| if ( infos.size() != pBuildRangeInfos.size() ) | |
| { | |
| throw LogicError( VULKAN_HPP_NAMESPACE_STRING | |
| "::Device::buildAccelerationStructuresKHR: infos.size() != pBuildRangeInfos.size()" ); | |
| } | |
| # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ | |
| Result result = static_cast<Result>( d.vkBuildAccelerationStructuresKHR( | |
| m_device, | |
| static_cast<VkDeferredOperationKHR>( deferredOperation ), | |
| infos.size(), | |
| reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>( infos.data() ), | |
| reinterpret_cast<const VkAccelerationStructureBuildRangeInfoKHR * const *>( pBuildRangeInfos.data() ) ) ); | |
| return createResultValue( result, | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::buildAccelerationStructuresKHR", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, | |
| VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR, | |
| VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR } ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::copyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, | |
| const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR * pInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkCopyAccelerationStructureKHR( m_device, | |
| static_cast<VkDeferredOperationKHR>( deferredOperation ), | |
| reinterpret_cast<const VkCopyAccelerationStructureInfoKHR *>( pInfo ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::copyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, | |
| const CopyAccelerationStructureInfoKHR & info, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| Result result = static_cast<Result>( | |
| d.vkCopyAccelerationStructureKHR( m_device, | |
| static_cast<VkDeferredOperationKHR>( deferredOperation ), | |
| reinterpret_cast<const VkCopyAccelerationStructureInfoKHR *>( &info ) ) ); | |
| return createResultValue( result, | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::copyAccelerationStructureKHR", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, | |
| VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR, | |
| VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR } ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyAccelerationStructureToMemoryKHR( | |
| VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, | |
| const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR * pInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkCopyAccelerationStructureToMemoryKHR( | |
| m_device, | |
| static_cast<VkDeferredOperationKHR>( deferredOperation ), | |
| reinterpret_cast<const VkCopyAccelerationStructureToMemoryInfoKHR *>( pInfo ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::copyAccelerationStructureToMemoryKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, | |
| const CopyAccelerationStructureToMemoryInfoKHR & info, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| Result result = static_cast<Result>( d.vkCopyAccelerationStructureToMemoryKHR( | |
| m_device, | |
| static_cast<VkDeferredOperationKHR>( deferredOperation ), | |
| reinterpret_cast<const VkCopyAccelerationStructureToMemoryInfoKHR *>( &info ) ) ); | |
| return createResultValue( result, | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::copyAccelerationStructureToMemoryKHR", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, | |
| VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR, | |
| VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR } ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyMemoryToAccelerationStructureKHR( | |
| VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, | |
| const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR * pInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkCopyMemoryToAccelerationStructureKHR( | |
| m_device, | |
| static_cast<VkDeferredOperationKHR>( deferredOperation ), | |
| reinterpret_cast<const VkCopyMemoryToAccelerationStructureInfoKHR *>( pInfo ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::copyMemoryToAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, | |
| const CopyMemoryToAccelerationStructureInfoKHR & info, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| Result result = static_cast<Result>( d.vkCopyMemoryToAccelerationStructureKHR( | |
| m_device, | |
| static_cast<VkDeferredOperationKHR>( deferredOperation ), | |
| reinterpret_cast<const VkCopyMemoryToAccelerationStructureInfoKHR *>( &info ) ) ); | |
| return createResultValue( result, | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::copyMemoryToAccelerationStructureKHR", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, | |
| VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR, | |
| VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR } ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::writeAccelerationStructuresPropertiesKHR( | |
| uint32_t accelerationStructureCount, | |
| const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR * pAccelerationStructures, | |
| VULKAN_HPP_NAMESPACE::QueryType queryType, | |
| size_t dataSize, | |
| void * pData, | |
| size_t stride, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkWriteAccelerationStructuresPropertiesKHR( | |
| m_device, | |
| accelerationStructureCount, | |
| reinterpret_cast<const VkAccelerationStructureKHR *>( pAccelerationStructures ), | |
| static_cast<VkQueryType>( queryType ), | |
| dataSize, | |
| pData, | |
| stride ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename T, typename Dispatch> | |
| VULKAN_HPP_DEPRECATED( "This function is deprecated. Use one of the other flavours of it." ) | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<void>::type Device::writeAccelerationStructuresPropertiesKHR( | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures, | |
| VULKAN_HPP_NAMESPACE::QueryType queryType, | |
| ArrayProxy<T> const & data, | |
| size_t stride, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| Result result = static_cast<Result>( d.vkWriteAccelerationStructuresPropertiesKHR( | |
| m_device, | |
| accelerationStructures.size(), | |
| reinterpret_cast<const VkAccelerationStructureKHR *>( accelerationStructures.data() ), | |
| static_cast<VkQueryType>( queryType ), | |
| data.size() * sizeof( T ), | |
| reinterpret_cast<void *>( data.data() ), | |
| stride ) ); | |
| return createResultValue( result, | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::writeAccelerationStructuresPropertiesKHR" ); | |
| } | |
| template <typename T, typename Allocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<std::vector<T, Allocator>>::type | |
| Device::writeAccelerationStructuresPropertiesKHR( | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures, | |
| VULKAN_HPP_NAMESPACE::QueryType queryType, | |
| size_t dataSize, | |
| size_t stride, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_ASSERT( dataSize % sizeof( T ) == 0 ); | |
| std::vector<T, Allocator> data( dataSize / sizeof( T ) ); | |
| Result result = static_cast<Result>( d.vkWriteAccelerationStructuresPropertiesKHR( | |
| m_device, | |
| accelerationStructures.size(), | |
| reinterpret_cast<const VkAccelerationStructureKHR *>( accelerationStructures.data() ), | |
| static_cast<VkQueryType>( queryType ), | |
| data.size() * sizeof( T ), | |
| reinterpret_cast<void *>( data.data() ), | |
| stride ) ); | |
| return createResultValue( | |
| result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::writeAccelerationStructuresPropertiesKHR" ); | |
| } | |
| template <typename T, typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<T>::type | |
| Device::writeAccelerationStructuresPropertyKHR( | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures, | |
| VULKAN_HPP_NAMESPACE::QueryType queryType, | |
| size_t stride, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| T data; | |
| Result result = static_cast<Result>( d.vkWriteAccelerationStructuresPropertiesKHR( | |
| m_device, | |
| accelerationStructures.size(), | |
| reinterpret_cast<const VkAccelerationStructureKHR *>( accelerationStructures.data() ), | |
| static_cast<VkQueryType>( queryType ), | |
| sizeof( T ), | |
| reinterpret_cast<void *>( &data ), | |
| stride ) ); | |
| return createResultValue( | |
| result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::writeAccelerationStructuresPropertyKHR" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::copyAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR * pInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdCopyAccelerationStructureKHR( m_commandBuffer, | |
| reinterpret_cast<const VkCopyAccelerationStructureInfoKHR *>( pInfo ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureKHR( const CopyAccelerationStructureInfoKHR & info, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdCopyAccelerationStructureKHR( m_commandBuffer, | |
| reinterpret_cast<const VkCopyAccelerationStructureInfoKHR *>( &info ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureToMemoryKHR( | |
| const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR * pInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdCopyAccelerationStructureToMemoryKHR( | |
| m_commandBuffer, reinterpret_cast<const VkCopyAccelerationStructureToMemoryInfoKHR *>( pInfo ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::copyAccelerationStructureToMemoryKHR( const CopyAccelerationStructureToMemoryInfoKHR & info, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdCopyAccelerationStructureToMemoryKHR( | |
| m_commandBuffer, reinterpret_cast<const VkCopyAccelerationStructureToMemoryInfoKHR *>( &info ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::copyMemoryToAccelerationStructureKHR( | |
| const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR * pInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdCopyMemoryToAccelerationStructureKHR( | |
| m_commandBuffer, reinterpret_cast<const VkCopyMemoryToAccelerationStructureInfoKHR *>( pInfo ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::copyMemoryToAccelerationStructureKHR( const CopyMemoryToAccelerationStructureInfoKHR & info, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdCopyMemoryToAccelerationStructureKHR( | |
| m_commandBuffer, reinterpret_cast<const VkCopyMemoryToAccelerationStructureInfoKHR *>( &info ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE DeviceAddress Device::getAccelerationStructureAddressKHR( | |
| const VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR * pInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<DeviceAddress>( d.vkGetAccelerationStructureDeviceAddressKHR( | |
| m_device, reinterpret_cast<const VkAccelerationStructureDeviceAddressInfoKHR *>( pInfo ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE DeviceAddress Device::getAccelerationStructureAddressKHR( | |
| const AccelerationStructureDeviceAddressInfoKHR & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return d.vkGetAccelerationStructureDeviceAddressKHR( | |
| m_device, reinterpret_cast<const VkAccelerationStructureDeviceAddressInfoKHR *>( &info ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesKHR( | |
| uint32_t accelerationStructureCount, | |
| const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR * pAccelerationStructures, | |
| VULKAN_HPP_NAMESPACE::QueryType queryType, | |
| VULKAN_HPP_NAMESPACE::QueryPool queryPool, | |
| uint32_t firstQuery, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdWriteAccelerationStructuresPropertiesKHR( | |
| m_commandBuffer, | |
| accelerationStructureCount, | |
| reinterpret_cast<const VkAccelerationStructureKHR *>( pAccelerationStructures ), | |
| static_cast<VkQueryType>( queryType ), | |
| static_cast<VkQueryPool>( queryPool ), | |
| firstQuery ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesKHR( | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures, | |
| VULKAN_HPP_NAMESPACE::QueryType queryType, | |
| VULKAN_HPP_NAMESPACE::QueryPool queryPool, | |
| uint32_t firstQuery, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdWriteAccelerationStructuresPropertiesKHR( | |
| m_commandBuffer, | |
| accelerationStructures.size(), | |
| reinterpret_cast<const VkAccelerationStructureKHR *>( accelerationStructures.data() ), | |
| static_cast<VkQueryType>( queryType ), | |
| static_cast<VkQueryPool>( queryPool ), | |
| firstQuery ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::getAccelerationStructureCompatibilityKHR( | |
| const VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR * pVersionInfo, | |
| VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR * pCompatibility, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkGetDeviceAccelerationStructureCompatibilityKHR( | |
| m_device, | |
| reinterpret_cast<const VkAccelerationStructureVersionInfoKHR *>( pVersionInfo ), | |
| reinterpret_cast<VkAccelerationStructureCompatibilityKHR *>( pCompatibility ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR | |
| Device::getAccelerationStructureCompatibilityKHR( const AccelerationStructureVersionInfoKHR & versionInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR compatibility; | |
| d.vkGetDeviceAccelerationStructureCompatibilityKHR( | |
| m_device, | |
| reinterpret_cast<const VkAccelerationStructureVersionInfoKHR *>( &versionInfo ), | |
| reinterpret_cast<VkAccelerationStructureCompatibilityKHR *>( &compatibility ) ); | |
| return compatibility; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::getAccelerationStructureBuildSizesKHR( | |
| VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR buildType, | |
| const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR * pBuildInfo, | |
| const uint32_t * pMaxPrimitiveCounts, | |
| VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR * pSizeInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkGetAccelerationStructureBuildSizesKHR( | |
| m_device, | |
| static_cast<VkAccelerationStructureBuildTypeKHR>( buildType ), | |
| reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>( pBuildInfo ), | |
| pMaxPrimitiveCounts, | |
| reinterpret_cast<VkAccelerationStructureBuildSizesInfoKHR *>( pSizeInfo ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR | |
| Device::getAccelerationStructureBuildSizesKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR buildType, | |
| const AccelerationStructureBuildGeometryInfoKHR & buildInfo, | |
| ArrayProxy<const uint32_t> const & maxPrimitiveCounts, | |
| 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( maxPrimitiveCounts.size() == buildInfo.geometryCount ); | |
| # else | |
| if ( maxPrimitiveCounts.size() != buildInfo.geometryCount ) | |
| { | |
| throw LogicError( | |
| VULKAN_HPP_NAMESPACE_STRING | |
| "::Device::getAccelerationStructureBuildSizesKHR: maxPrimitiveCounts.size() != buildInfo.geometryCount" ); | |
| } | |
| # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ | |
| VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR sizeInfo; | |
| d.vkGetAccelerationStructureBuildSizesKHR( | |
| m_device, | |
| static_cast<VkAccelerationStructureBuildTypeKHR>( buildType ), | |
| reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>( &buildInfo ), | |
| maxPrimitiveCounts.data(), | |
| reinterpret_cast<VkAccelerationStructureBuildSizesInfoKHR *>( &sizeInfo ) ); | |
| return sizeInfo; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_KHR_sampler_ycbcr_conversion === | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::createSamplerYcbcrConversionKHR( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo * pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion * pYcbcrConversion, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkCreateSamplerYcbcrConversionKHR( m_device, | |
| reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo *>( pCreateInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), | |
| reinterpret_cast<VkSamplerYcbcrConversion *>( pYcbcrConversion ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>::type | |
| Device::createSamplerYcbcrConversionKHR( const SamplerYcbcrConversionCreateInfo & createInfo, | |
| Optional<const 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.vkCreateSamplerYcbcrConversionKHR( | |
| 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::createSamplerYcbcrConversionKHR" ); | |
| } | |
| # 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::createSamplerYcbcrConversionKHRUnique( const SamplerYcbcrConversionCreateInfo & createInfo, | |
| Optional<const 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.vkCreateSamplerYcbcrConversionKHR( | |
| 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::createSamplerYcbcrConversionKHRUnique", deleter ); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| Device::destroySamplerYcbcrConversionKHR( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroySamplerYcbcrConversionKHR( m_device, | |
| static_cast<VkSamplerYcbcrConversion>( ycbcrConversion ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| Device::destroySamplerYcbcrConversionKHR( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion, | |
| Optional<const AllocationCallbacks> allocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroySamplerYcbcrConversionKHR( | |
| m_device, | |
| static_cast<VkSamplerYcbcrConversion>( ycbcrConversion ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_KHR_bind_memory2 === | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::bindBufferMemory2KHR( uint32_t bindInfoCount, | |
| const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo * pBindInfos, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkBindBufferMemory2KHR( | |
| m_device, bindInfoCount, reinterpret_cast<const VkBindBufferMemoryInfo *>( pBindInfos ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| Device::bindBufferMemory2KHR( 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.vkBindBufferMemory2KHR( | |
| m_device, bindInfos.size(), reinterpret_cast<const VkBindBufferMemoryInfo *>( bindInfos.data() ) ) ); | |
| return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindBufferMemory2KHR" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::bindImageMemory2KHR( uint32_t bindInfoCount, | |
| const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo * pBindInfos, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkBindImageMemory2KHR( | |
| m_device, bindInfoCount, reinterpret_cast<const VkBindImageMemoryInfo *>( pBindInfos ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| Device::bindImageMemory2KHR( 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.vkBindImageMemory2KHR( | |
| m_device, bindInfos.size(), reinterpret_cast<const VkBindImageMemoryInfo *>( bindInfos.data() ) ) ); | |
| return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindImageMemory2KHR" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_EXT_image_drm_format_modifier === | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getImageDrmFormatModifierPropertiesEXT( | |
| VULKAN_HPP_NAMESPACE::Image image, | |
| VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT * pProperties, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkGetImageDrmFormatModifierPropertiesEXT( | |
| m_device, | |
| static_cast<VkImage>( image ), | |
| reinterpret_cast<VkImageDrmFormatModifierPropertiesEXT *>( pProperties ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT>::type | |
| Device::getImageDrmFormatModifierPropertiesEXT( VULKAN_HPP_NAMESPACE::Image image, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT properties; | |
| Result result = static_cast<Result>( d.vkGetImageDrmFormatModifierPropertiesEXT( | |
| m_device, | |
| static_cast<VkImage>( image ), | |
| reinterpret_cast<VkImageDrmFormatModifierPropertiesEXT *>( &properties ) ) ); | |
| return createResultValue( | |
| result, properties, VULKAN_HPP_NAMESPACE_STRING "::Device::getImageDrmFormatModifierPropertiesEXT" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_EXT_validation_cache === | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::createValidationCacheEXT( const VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT * pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| VULKAN_HPP_NAMESPACE::ValidationCacheEXT * pValidationCache, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkCreateValidationCacheEXT( m_device, | |
| reinterpret_cast<const VkValidationCacheCreateInfoEXT *>( pCreateInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), | |
| reinterpret_cast<VkValidationCacheEXT *>( pValidationCache ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::ValidationCacheEXT>::type | |
| Device::createValidationCacheEXT( const ValidationCacheCreateInfoEXT & createInfo, | |
| Optional<const AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache; | |
| Result result = static_cast<Result>( | |
| d.vkCreateValidationCacheEXT( m_device, | |
| reinterpret_cast<const VkValidationCacheCreateInfoEXT *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkValidationCacheEXT *>( &validationCache ) ) ); | |
| return createResultValue( | |
| result, validationCache, VULKAN_HPP_NAMESPACE_STRING "::Device::createValidationCacheEXT" ); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ValidationCacheEXT, Dispatch>>::type | |
| Device::createValidationCacheEXTUnique( const ValidationCacheCreateInfoEXT & createInfo, | |
| Optional<const AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache; | |
| Result result = static_cast<Result>( | |
| d.vkCreateValidationCacheEXT( m_device, | |
| reinterpret_cast<const VkValidationCacheCreateInfoEXT *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkValidationCacheEXT *>( &validationCache ) ) ); | |
| ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d ); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::ValidationCacheEXT, Dispatch>( | |
| result, validationCache, VULKAN_HPP_NAMESPACE_STRING "::Device::createValidationCacheEXTUnique", deleter ); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| Device::destroyValidationCacheEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyValidationCacheEXT( m_device, | |
| static_cast<VkValidationCacheEXT>( validationCache ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroyValidationCacheEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache, | |
| Optional<const AllocationCallbacks> allocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyValidationCacheEXT( m_device, | |
| static_cast<VkValidationCacheEXT>( validationCache ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyValidationCacheEXT( m_device, | |
| static_cast<VkValidationCacheEXT>( validationCache ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache, | |
| Optional<const AllocationCallbacks> allocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyValidationCacheEXT( m_device, | |
| static_cast<VkValidationCacheEXT>( validationCache ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::mergeValidationCachesEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT dstCache, | |
| uint32_t srcCacheCount, | |
| const VULKAN_HPP_NAMESPACE::ValidationCacheEXT * pSrcCaches, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkMergeValidationCachesEXT( m_device, | |
| static_cast<VkValidationCacheEXT>( dstCache ), | |
| srcCacheCount, | |
| reinterpret_cast<const VkValidationCacheEXT *>( pSrcCaches ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| Device::mergeValidationCachesEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT dstCache, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::ValidationCacheEXT> const & srcCaches, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| Result result = static_cast<Result>( | |
| d.vkMergeValidationCachesEXT( m_device, | |
| static_cast<VkValidationCacheEXT>( dstCache ), | |
| srcCaches.size(), | |
| reinterpret_cast<const VkValidationCacheEXT *>( srcCaches.data() ) ) ); | |
| return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::mergeValidationCachesEXT" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::getValidationCacheDataEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache, | |
| size_t * pDataSize, | |
| void * pData, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkGetValidationCacheDataEXT( | |
| m_device, static_cast<VkValidationCacheEXT>( validationCache ), pDataSize, pData ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Uint8_tAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type | |
| Device::getValidationCacheDataEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<uint8_t, Uint8_tAllocator> data; | |
| size_t dataSize; | |
| Result result; | |
| do | |
| { | |
| result = static_cast<Result>( d.vkGetValidationCacheDataEXT( | |
| m_device, static_cast<VkValidationCacheEXT>( validationCache ), &dataSize, nullptr ) ); | |
| if ( ( result == Result::eSuccess ) && dataSize ) | |
| { | |
| data.resize( dataSize ); | |
| result = | |
| static_cast<Result>( d.vkGetValidationCacheDataEXT( m_device, | |
| static_cast<VkValidationCacheEXT>( validationCache ), | |
| &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::getValidationCacheDataEXT" ); | |
| } | |
| 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::getValidationCacheDataEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache, | |
| 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.vkGetValidationCacheDataEXT( | |
| m_device, static_cast<VkValidationCacheEXT>( validationCache ), &dataSize, nullptr ) ); | |
| if ( ( result == Result::eSuccess ) && dataSize ) | |
| { | |
| data.resize( dataSize ); | |
| result = | |
| static_cast<Result>( d.vkGetValidationCacheDataEXT( m_device, | |
| static_cast<VkValidationCacheEXT>( validationCache ), | |
| &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::getValidationCacheDataEXT" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_NV_shading_rate_image === | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::bindShadingRateImageNV( VULKAN_HPP_NAMESPACE::ImageView imageView, | |
| VULKAN_HPP_NAMESPACE::ImageLayout imageLayout, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdBindShadingRateImageNV( | |
| m_commandBuffer, static_cast<VkImageView>( imageView ), static_cast<VkImageLayout>( imageLayout ) ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setViewportShadingRatePaletteNV( | |
| uint32_t firstViewport, | |
| uint32_t viewportCount, | |
| const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV * pShadingRatePalettes, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdSetViewportShadingRatePaletteNV( m_commandBuffer, | |
| firstViewport, | |
| viewportCount, | |
| reinterpret_cast<const VkShadingRatePaletteNV *>( pShadingRatePalettes ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setViewportShadingRatePaletteNV( | |
| uint32_t firstViewport, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV> const & shadingRatePalettes, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdSetViewportShadingRatePaletteNV( | |
| m_commandBuffer, | |
| firstViewport, | |
| shadingRatePalettes.size(), | |
| reinterpret_cast<const VkShadingRatePaletteNV *>( shadingRatePalettes.data() ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::setCoarseSampleOrderNV( VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV sampleOrderType, | |
| uint32_t customSampleOrderCount, | |
| const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV * pCustomSampleOrders, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdSetCoarseSampleOrderNV( m_commandBuffer, | |
| static_cast<VkCoarseSampleOrderTypeNV>( sampleOrderType ), | |
| customSampleOrderCount, | |
| reinterpret_cast<const VkCoarseSampleOrderCustomNV *>( pCustomSampleOrders ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setCoarseSampleOrderNV( | |
| VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV sampleOrderType, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV> const & customSampleOrders, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdSetCoarseSampleOrderNV( m_commandBuffer, | |
| static_cast<VkCoarseSampleOrderTypeNV>( sampleOrderType ), | |
| customSampleOrders.size(), | |
| reinterpret_cast<const VkCoarseSampleOrderCustomNV *>( customSampleOrders.data() ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_NV_ray_tracing === | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::createAccelerationStructureNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV * pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| VULKAN_HPP_NAMESPACE::AccelerationStructureNV * pAccelerationStructure, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkCreateAccelerationStructureNV( m_device, | |
| reinterpret_cast<const VkAccelerationStructureCreateInfoNV *>( pCreateInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), | |
| reinterpret_cast<VkAccelerationStructureNV *>( pAccelerationStructure ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::AccelerationStructureNV>::type | |
| Device::createAccelerationStructureNV( const AccelerationStructureCreateInfoNV & createInfo, | |
| Optional<const AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure; | |
| Result result = static_cast<Result>( d.vkCreateAccelerationStructureNV( | |
| m_device, | |
| reinterpret_cast<const VkAccelerationStructureCreateInfoNV *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkAccelerationStructureNV *>( &accelerationStructure ) ) ); | |
| return createResultValue( | |
| result, accelerationStructure, VULKAN_HPP_NAMESPACE_STRING "::Device::createAccelerationStructureNV" ); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE | |
| typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::AccelerationStructureNV, Dispatch>>::type | |
| Device::createAccelerationStructureNVUnique( const AccelerationStructureCreateInfoNV & createInfo, | |
| Optional<const AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure; | |
| Result result = static_cast<Result>( d.vkCreateAccelerationStructureNV( | |
| m_device, | |
| reinterpret_cast<const VkAccelerationStructureCreateInfoNV *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkAccelerationStructureNV *>( &accelerationStructure ) ) ); | |
| ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d ); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::AccelerationStructureNV, Dispatch>( | |
| result, | |
| accelerationStructure, | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createAccelerationStructureNVUnique", | |
| deleter ); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| Device::destroyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyAccelerationStructureNV( m_device, | |
| static_cast<VkAccelerationStructureNV>( accelerationStructure ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| Device::destroyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure, | |
| Optional<const AllocationCallbacks> allocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyAccelerationStructureNV( | |
| m_device, | |
| static_cast<VkAccelerationStructureNV>( accelerationStructure ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyAccelerationStructureNV( m_device, | |
| static_cast<VkAccelerationStructureNV>( accelerationStructure ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure, | |
| Optional<const AllocationCallbacks> allocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyAccelerationStructureNV( | |
| m_device, | |
| static_cast<VkAccelerationStructureNV>( accelerationStructure ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::getAccelerationStructureMemoryRequirementsNV( | |
| const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV * pInfo, | |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR * pMemoryRequirements, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkGetAccelerationStructureMemoryRequirementsNV( | |
| m_device, | |
| reinterpret_cast<const VkAccelerationStructureMemoryRequirementsInfoNV *>( pInfo ), | |
| reinterpret_cast<VkMemoryRequirements2KHR *>( pMemoryRequirements ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR | |
| Device::getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV & info, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR memoryRequirements; | |
| d.vkGetAccelerationStructureMemoryRequirementsNV( | |
| m_device, | |
| reinterpret_cast<const VkAccelerationStructureMemoryRequirementsInfoNV *>( &info ), | |
| reinterpret_cast<VkMemoryRequirements2KHR *>( &memoryRequirements ) ); | |
| return memoryRequirements; | |
| } | |
| template <typename X, typename Y, typename... Z, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> | |
| Device::getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV & info, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| StructureChain<X, Y, Z...> structureChain; | |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR & memoryRequirements = | |
| structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR>(); | |
| d.vkGetAccelerationStructureMemoryRequirementsNV( | |
| m_device, | |
| reinterpret_cast<const VkAccelerationStructureMemoryRequirementsInfoNV *>( &info ), | |
| reinterpret_cast<VkMemoryRequirements2KHR *>( &memoryRequirements ) ); | |
| return structureChain; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::bindAccelerationStructureMemoryNV( | |
| uint32_t bindInfoCount, | |
| const VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV * pBindInfos, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkBindAccelerationStructureMemoryNV( | |
| m_device, bindInfoCount, reinterpret_cast<const VkBindAccelerationStructureMemoryInfoNV *>( pBindInfos ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| Device::bindAccelerationStructureMemoryNV( | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV> const & bindInfos, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| Result result = static_cast<Result>( d.vkBindAccelerationStructureMemoryNV( | |
| m_device, | |
| bindInfos.size(), | |
| reinterpret_cast<const VkBindAccelerationStructureMemoryInfoNV *>( bindInfos.data() ) ) ); | |
| return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindAccelerationStructureMemoryNV" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::buildAccelerationStructureNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV * pInfo, | |
| VULKAN_HPP_NAMESPACE::Buffer instanceData, | |
| VULKAN_HPP_NAMESPACE::DeviceSize instanceOffset, | |
| VULKAN_HPP_NAMESPACE::Bool32 update, | |
| VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst, | |
| VULKAN_HPP_NAMESPACE::AccelerationStructureNV src, | |
| VULKAN_HPP_NAMESPACE::Buffer scratch, | |
| VULKAN_HPP_NAMESPACE::DeviceSize scratchOffset, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdBuildAccelerationStructureNV( m_commandBuffer, | |
| reinterpret_cast<const VkAccelerationStructureInfoNV *>( pInfo ), | |
| static_cast<VkBuffer>( instanceData ), | |
| static_cast<VkDeviceSize>( instanceOffset ), | |
| static_cast<VkBool32>( update ), | |
| static_cast<VkAccelerationStructureNV>( dst ), | |
| static_cast<VkAccelerationStructureNV>( src ), | |
| static_cast<VkBuffer>( scratch ), | |
| static_cast<VkDeviceSize>( scratchOffset ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructureNV( const AccelerationStructureInfoNV & info, | |
| VULKAN_HPP_NAMESPACE::Buffer instanceData, | |
| VULKAN_HPP_NAMESPACE::DeviceSize instanceOffset, | |
| VULKAN_HPP_NAMESPACE::Bool32 update, | |
| VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst, | |
| VULKAN_HPP_NAMESPACE::AccelerationStructureNV src, | |
| VULKAN_HPP_NAMESPACE::Buffer scratch, | |
| VULKAN_HPP_NAMESPACE::DeviceSize scratchOffset, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdBuildAccelerationStructureNV( m_commandBuffer, | |
| reinterpret_cast<const VkAccelerationStructureInfoNV *>( &info ), | |
| static_cast<VkBuffer>( instanceData ), | |
| static_cast<VkDeviceSize>( instanceOffset ), | |
| static_cast<VkBool32>( update ), | |
| static_cast<VkAccelerationStructureNV>( dst ), | |
| static_cast<VkAccelerationStructureNV>( src ), | |
| static_cast<VkBuffer>( scratch ), | |
| static_cast<VkDeviceSize>( scratchOffset ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::copyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst, | |
| VULKAN_HPP_NAMESPACE::AccelerationStructureNV src, | |
| VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR mode, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdCopyAccelerationStructureNV( m_commandBuffer, | |
| static_cast<VkAccelerationStructureNV>( dst ), | |
| static_cast<VkAccelerationStructureNV>( src ), | |
| static_cast<VkCopyAccelerationStructureModeKHR>( mode ) ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::traceRaysNV( VULKAN_HPP_NAMESPACE::Buffer raygenShaderBindingTableBuffer, | |
| VULKAN_HPP_NAMESPACE::DeviceSize raygenShaderBindingOffset, | |
| VULKAN_HPP_NAMESPACE::Buffer missShaderBindingTableBuffer, | |
| VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingOffset, | |
| VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingStride, | |
| VULKAN_HPP_NAMESPACE::Buffer hitShaderBindingTableBuffer, | |
| VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingOffset, | |
| VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingStride, | |
| VULKAN_HPP_NAMESPACE::Buffer callableShaderBindingTableBuffer, | |
| VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingOffset, | |
| VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingStride, | |
| uint32_t width, | |
| uint32_t height, | |
| uint32_t depth, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdTraceRaysNV( m_commandBuffer, | |
| static_cast<VkBuffer>( raygenShaderBindingTableBuffer ), | |
| static_cast<VkDeviceSize>( raygenShaderBindingOffset ), | |
| static_cast<VkBuffer>( missShaderBindingTableBuffer ), | |
| static_cast<VkDeviceSize>( missShaderBindingOffset ), | |
| static_cast<VkDeviceSize>( missShaderBindingStride ), | |
| static_cast<VkBuffer>( hitShaderBindingTableBuffer ), | |
| static_cast<VkDeviceSize>( hitShaderBindingOffset ), | |
| static_cast<VkDeviceSize>( hitShaderBindingStride ), | |
| static_cast<VkBuffer>( callableShaderBindingTableBuffer ), | |
| static_cast<VkDeviceSize>( callableShaderBindingOffset ), | |
| static_cast<VkDeviceSize>( callableShaderBindingStride ), | |
| width, | |
| height, | |
| depth ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::createRayTracingPipelinesNV( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| uint32_t createInfoCount, | |
| const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV * pCreateInfos, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| VULKAN_HPP_NAMESPACE::Pipeline * pPipelines, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkCreateRayTracingPipelinesNV( m_device, | |
| static_cast<VkPipelineCache>( pipelineCache ), | |
| createInfoCount, | |
| reinterpret_cast<const VkRayTracingPipelineCreateInfoNV *>( pCreateInfos ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), | |
| reinterpret_cast<VkPipeline *>( pPipelines ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename PipelineAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<Pipeline, PipelineAllocator>> | |
| Device::createRayTracingPipelinesNV( | |
| VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos, | |
| Optional<const AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<Pipeline, PipelineAllocator> pipelines( createInfos.size() ); | |
| Result result = static_cast<Result>( | |
| d.vkCreateRayTracingPipelinesNV( m_device, | |
| static_cast<VkPipelineCache>( pipelineCache ), | |
| createInfos.size(), | |
| reinterpret_cast<const VkRayTracingPipelineCreateInfoNV *>( createInfos.data() ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkPipeline *>( pipelines.data() ) ) ); | |
| return createResultValue( | |
| result, | |
| pipelines, | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesNV", | |
| { 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<Pipeline, PipelineAllocator>> | |
| Device::createRayTracingPipelinesNV( | |
| VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos, | |
| Optional<const AllocationCallbacks> allocator, | |
| PipelineAllocator & pipelineAllocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<Pipeline, PipelineAllocator> pipelines( createInfos.size(), pipelineAllocator ); | |
| Result result = static_cast<Result>( | |
| d.vkCreateRayTracingPipelinesNV( m_device, | |
| static_cast<VkPipelineCache>( pipelineCache ), | |
| createInfos.size(), | |
| reinterpret_cast<const VkRayTracingPipelineCreateInfoNV *>( createInfos.data() ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkPipeline *>( pipelines.data() ) ) ); | |
| return createResultValue( | |
| result, | |
| pipelines, | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesNV", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<Pipeline> | |
| Device::createRayTracingPipelineNV( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV & createInfo, | |
| Optional<const AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| Pipeline pipeline; | |
| Result result = static_cast<Result>( | |
| d.vkCreateRayTracingPipelinesNV( m_device, | |
| static_cast<VkPipelineCache>( pipelineCache ), | |
| 1, | |
| reinterpret_cast<const VkRayTracingPipelineCreateInfoNV *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkPipeline *>( &pipeline ) ) ); | |
| return createResultValue( | |
| result, | |
| pipeline, | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelineNV", | |
| { 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::createRayTracingPipelinesNVUnique( | |
| VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos, | |
| Optional<const 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.vkCreateRayTracingPipelinesNV( m_device, | |
| static_cast<VkPipelineCache>( pipelineCache ), | |
| createInfos.size(), | |
| reinterpret_cast<const VkRayTracingPipelineCreateInfoNV *>( createInfos.data() ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkPipeline *>( pipelines.data() ) ) ); | |
| 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::createRayTracingPipelinesNVUnique", | |
| { 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::createRayTracingPipelinesNVUnique( | |
| VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos, | |
| Optional<const 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.vkCreateRayTracingPipelinesNV( m_device, | |
| static_cast<VkPipelineCache>( pipelineCache ), | |
| createInfos.size(), | |
| reinterpret_cast<const VkRayTracingPipelineCreateInfoNV *>( createInfos.data() ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkPipeline *>( pipelines.data() ) ) ); | |
| 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::createRayTracingPipelinesNVUnique", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<UniqueHandle<Pipeline, Dispatch>> | |
| Device::createRayTracingPipelineNVUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV & createInfo, | |
| Optional<const AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| Pipeline pipeline; | |
| Result result = static_cast<Result>( | |
| d.vkCreateRayTracingPipelinesNV( m_device, | |
| static_cast<VkPipelineCache>( pipelineCache ), | |
| 1, | |
| reinterpret_cast<const VkRayTracingPipelineCreateInfoNV *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkPipeline *>( &pipeline ) ) ); | |
| ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d ); | |
| return createResultValue<Pipeline, Dispatch>( | |
| result, | |
| pipeline, | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelineNVUnique", | |
| { 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::getRayTracingShaderGroupHandlesNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline, | |
| uint32_t firstGroup, | |
| uint32_t groupCount, | |
| size_t dataSize, | |
| void * pData, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesNV( | |
| m_device, static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, dataSize, pData ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename T, typename Dispatch> | |
| VULKAN_HPP_DEPRECATED( "This function is deprecated. Use one of the other flavours of it." ) | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<void>::type Device::getRayTracingShaderGroupHandlesNV( | |
| VULKAN_HPP_NAMESPACE::Pipeline pipeline, | |
| uint32_t firstGroup, | |
| uint32_t groupCount, | |
| ArrayProxy<T> const & data, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| Result result = | |
| static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesNV( m_device, | |
| static_cast<VkPipeline>( pipeline ), | |
| firstGroup, | |
| groupCount, | |
| data.size() * sizeof( T ), | |
| reinterpret_cast<void *>( data.data() ) ) ); | |
| return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandlesNV" ); | |
| } | |
| template <typename T, typename Allocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<std::vector<T, Allocator>>::type | |
| Device::getRayTracingShaderGroupHandlesNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline, | |
| uint32_t firstGroup, | |
| uint32_t groupCount, | |
| size_t dataSize, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_ASSERT( dataSize % sizeof( T ) == 0 ); | |
| std::vector<T, Allocator> data( dataSize / sizeof( T ) ); | |
| Result result = | |
| static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesNV( m_device, | |
| static_cast<VkPipeline>( pipeline ), | |
| firstGroup, | |
| groupCount, | |
| data.size() * sizeof( T ), | |
| reinterpret_cast<void *>( data.data() ) ) ); | |
| return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandlesNV" ); | |
| } | |
| template <typename T, typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<T>::type | |
| Device::getRayTracingShaderGroupHandleNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline, | |
| uint32_t firstGroup, | |
| uint32_t groupCount, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| T data; | |
| Result result = static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesNV( m_device, | |
| static_cast<VkPipeline>( pipeline ), | |
| firstGroup, | |
| groupCount, | |
| sizeof( T ), | |
| reinterpret_cast<void *>( &data ) ) ); | |
| return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandleNV" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure, | |
| size_t dataSize, | |
| void * pData, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkGetAccelerationStructureHandleNV( | |
| m_device, static_cast<VkAccelerationStructureNV>( accelerationStructure ), dataSize, pData ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename T, typename Dispatch> | |
| VULKAN_HPP_DEPRECATED( "This function is deprecated. Use one of the other flavours of it." ) | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<void>::type Device::getAccelerationStructureHandleNV( | |
| VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure, | |
| ArrayProxy<T> const & data, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| Result result = static_cast<Result>( | |
| d.vkGetAccelerationStructureHandleNV( m_device, | |
| static_cast<VkAccelerationStructureNV>( accelerationStructure ), | |
| data.size() * sizeof( T ), | |
| reinterpret_cast<void *>( data.data() ) ) ); | |
| return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getAccelerationStructureHandleNV" ); | |
| } | |
| template <typename T, typename Allocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<std::vector<T, Allocator>>::type | |
| Device::getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure, | |
| size_t dataSize, | |
| 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.vkGetAccelerationStructureHandleNV( m_device, | |
| static_cast<VkAccelerationStructureNV>( accelerationStructure ), | |
| data.size() * sizeof( T ), | |
| reinterpret_cast<void *>( data.data() ) ) ); | |
| return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getAccelerationStructureHandleNV" ); | |
| } | |
| template <typename T, typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<T>::type | |
| Device::getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| T data; | |
| Result result = static_cast<Result>( | |
| d.vkGetAccelerationStructureHandleNV( m_device, | |
| static_cast<VkAccelerationStructureNV>( accelerationStructure ), | |
| sizeof( T ), | |
| reinterpret_cast<void *>( &data ) ) ); | |
| return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getAccelerationStructureHandleNV" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesNV( | |
| uint32_t accelerationStructureCount, | |
| const VULKAN_HPP_NAMESPACE::AccelerationStructureNV * pAccelerationStructures, | |
| VULKAN_HPP_NAMESPACE::QueryType queryType, | |
| VULKAN_HPP_NAMESPACE::QueryPool queryPool, | |
| uint32_t firstQuery, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdWriteAccelerationStructuresPropertiesNV( | |
| m_commandBuffer, | |
| accelerationStructureCount, | |
| reinterpret_cast<const VkAccelerationStructureNV *>( pAccelerationStructures ), | |
| static_cast<VkQueryType>( queryType ), | |
| static_cast<VkQueryPool>( queryPool ), | |
| firstQuery ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesNV( | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureNV> const & accelerationStructures, | |
| VULKAN_HPP_NAMESPACE::QueryType queryType, | |
| VULKAN_HPP_NAMESPACE::QueryPool queryPool, | |
| uint32_t firstQuery, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdWriteAccelerationStructuresPropertiesNV( | |
| m_commandBuffer, | |
| accelerationStructures.size(), | |
| reinterpret_cast<const VkAccelerationStructureNV *>( accelerationStructures.data() ), | |
| static_cast<VkQueryType>( queryType ), | |
| static_cast<VkQueryPool>( queryPool ), | |
| firstQuery ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::compileDeferredNV( | |
| VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t shader, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkCompileDeferredNV( m_device, static_cast<VkPipeline>( pipeline ), shader ) ); | |
| } | |
| #else | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| Device::compileDeferredNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t shader, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| Result result = | |
| static_cast<Result>( d.vkCompileDeferredNV( m_device, static_cast<VkPipeline>( pipeline ), shader ) ); | |
| return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::compileDeferredNV" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_KHR_maintenance3 === | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| Device::getDescriptorSetLayoutSupportKHR( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo * pCreateInfo, | |
| VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport * pSupport, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkGetDescriptorSetLayoutSupportKHR( m_device, | |
| reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( pCreateInfo ), | |
| reinterpret_cast<VkDescriptorSetLayoutSupport *>( pSupport ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport | |
| Device::getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport support; | |
| d.vkGetDescriptorSetLayoutSupportKHR( m_device, | |
| reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( &createInfo ), | |
| reinterpret_cast<VkDescriptorSetLayoutSupport *>( &support ) ); | |
| return support; | |
| } | |
| template <typename X, typename Y, typename... Z, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> | |
| Device::getDescriptorSetLayoutSupportKHR( const 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.vkGetDescriptorSetLayoutSupportKHR( m_device, | |
| reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( &createInfo ), | |
| reinterpret_cast<VkDescriptorSetLayoutSupport *>( &support ) ); | |
| return structureChain; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_KHR_draw_indirect_count === | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer buffer, | |
| VULKAN_HPP_NAMESPACE::DeviceSize offset, | |
| VULKAN_HPP_NAMESPACE::Buffer countBuffer, | |
| VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, | |
| uint32_t maxDrawCount, | |
| uint32_t stride, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdDrawIndirectCountKHR( m_commandBuffer, | |
| static_cast<VkBuffer>( buffer ), | |
| static_cast<VkDeviceSize>( offset ), | |
| static_cast<VkBuffer>( countBuffer ), | |
| static_cast<VkDeviceSize>( countBufferOffset ), | |
| maxDrawCount, | |
| stride ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer buffer, | |
| VULKAN_HPP_NAMESPACE::DeviceSize offset, | |
| VULKAN_HPP_NAMESPACE::Buffer countBuffer, | |
| VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, | |
| uint32_t maxDrawCount, | |
| uint32_t stride, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdDrawIndexedIndirectCountKHR( m_commandBuffer, | |
| static_cast<VkBuffer>( buffer ), | |
| static_cast<VkDeviceSize>( offset ), | |
| static_cast<VkBuffer>( countBuffer ), | |
| static_cast<VkDeviceSize>( countBufferOffset ), | |
| maxDrawCount, | |
| stride ); | |
| } | |
| //=== VK_EXT_external_memory_host === | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getMemoryHostPointerPropertiesEXT( | |
| VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, | |
| const void * pHostPointer, | |
| VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT * pMemoryHostPointerProperties, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkGetMemoryHostPointerPropertiesEXT( | |
| m_device, | |
| static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ), | |
| pHostPointer, | |
| reinterpret_cast<VkMemoryHostPointerPropertiesEXT *>( pMemoryHostPointerProperties ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT>::type | |
| Device::getMemoryHostPointerPropertiesEXT( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, | |
| const void * pHostPointer, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT memoryHostPointerProperties; | |
| Result result = static_cast<Result>( d.vkGetMemoryHostPointerPropertiesEXT( | |
| m_device, | |
| static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ), | |
| pHostPointer, | |
| reinterpret_cast<VkMemoryHostPointerPropertiesEXT *>( &memoryHostPointerProperties ) ) ); | |
| return createResultValue( | |
| result, memoryHostPointerProperties, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryHostPointerPropertiesEXT" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_AMD_buffer_marker === | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::writeBufferMarkerAMD( VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage, | |
| VULKAN_HPP_NAMESPACE::Buffer dstBuffer, | |
| VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, | |
| uint32_t marker, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdWriteBufferMarkerAMD( m_commandBuffer, | |
| static_cast<VkPipelineStageFlagBits>( pipelineStage ), | |
| static_cast<VkBuffer>( dstBuffer ), | |
| static_cast<VkDeviceSize>( dstOffset ), | |
| marker ); | |
| } | |
| //=== VK_EXT_calibrated_timestamps === | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| PhysicalDevice::getCalibrateableTimeDomainsEXT( uint32_t * pTimeDomainCount, | |
| VULKAN_HPP_NAMESPACE::TimeDomainEXT * pTimeDomains, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( | |
| m_physicalDevice, pTimeDomainCount, reinterpret_cast<VkTimeDomainEXT *>( pTimeDomains ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename TimeDomainEXTAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE | |
| typename ResultValueType<std::vector<TimeDomainEXT, TimeDomainEXTAllocator>>::type | |
| PhysicalDevice::getCalibrateableTimeDomainsEXT( Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<TimeDomainEXT, TimeDomainEXTAllocator> timeDomains; | |
| uint32_t timeDomainCount; | |
| Result result; | |
| do | |
| { | |
| result = static_cast<Result>( | |
| d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( m_physicalDevice, &timeDomainCount, nullptr ) ); | |
| if ( ( result == Result::eSuccess ) && timeDomainCount ) | |
| { | |
| timeDomains.resize( timeDomainCount ); | |
| result = static_cast<Result>( d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( | |
| m_physicalDevice, &timeDomainCount, reinterpret_cast<VkTimeDomainEXT *>( timeDomains.data() ) ) ); | |
| VULKAN_HPP_ASSERT( timeDomainCount <= timeDomains.size() ); | |
| } | |
| } while ( result == Result::eIncomplete ); | |
| if ( ( result == Result::eSuccess ) && ( timeDomainCount < timeDomains.size() ) ) | |
| { | |
| timeDomains.resize( timeDomainCount ); | |
| } | |
| return createResultValue( | |
| result, timeDomains, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCalibrateableTimeDomainsEXT" ); | |
| } | |
| template <typename TimeDomainEXTAllocator, | |
| typename Dispatch, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, TimeDomainEXT>::value, int>::type> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE | |
| typename ResultValueType<std::vector<TimeDomainEXT, TimeDomainEXTAllocator>>::type | |
| PhysicalDevice::getCalibrateableTimeDomainsEXT( TimeDomainEXTAllocator & timeDomainEXTAllocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<TimeDomainEXT, TimeDomainEXTAllocator> timeDomains( timeDomainEXTAllocator ); | |
| uint32_t timeDomainCount; | |
| Result result; | |
| do | |
| { | |
| result = static_cast<Result>( | |
| d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( m_physicalDevice, &timeDomainCount, nullptr ) ); | |
| if ( ( result == Result::eSuccess ) && timeDomainCount ) | |
| { | |
| timeDomains.resize( timeDomainCount ); | |
| result = static_cast<Result>( d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( | |
| m_physicalDevice, &timeDomainCount, reinterpret_cast<VkTimeDomainEXT *>( timeDomains.data() ) ) ); | |
| VULKAN_HPP_ASSERT( timeDomainCount <= timeDomains.size() ); | |
| } | |
| } while ( result == Result::eIncomplete ); | |
| if ( ( result == Result::eSuccess ) && ( timeDomainCount < timeDomains.size() ) ) | |
| { | |
| timeDomains.resize( timeDomainCount ); | |
| } | |
| return createResultValue( | |
| result, timeDomains, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCalibrateableTimeDomainsEXT" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::getCalibratedTimestampsEXT( uint32_t timestampCount, | |
| const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT * pTimestampInfos, | |
| uint64_t * pTimestamps, | |
| uint64_t * pMaxDeviation, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkGetCalibratedTimestampsEXT( m_device, | |
| timestampCount, | |
| reinterpret_cast<const VkCalibratedTimestampInfoEXT *>( pTimestampInfos ), | |
| pTimestamps, | |
| pMaxDeviation ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_DEPRECATED( "This function is deprecated. Use one of the other flavours of it." ) | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<uint64_t>::type Device::getCalibratedTimestampsEXT( | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT> const & timestampInfos, | |
| ArrayProxy<uint64_t> const & timestamps, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| # ifdef VULKAN_HPP_NO_EXCEPTIONS | |
| VULKAN_HPP_ASSERT( timestampInfos.size() == timestamps.size() ); | |
| # else | |
| if ( timestampInfos.size() != timestamps.size() ) | |
| { | |
| throw LogicError( VULKAN_HPP_NAMESPACE_STRING | |
| "::VkDevice::getCalibratedTimestampsEXT: timestampInfos.size() != timestamps.size()" ); | |
| } | |
| # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ | |
| uint64_t maxDeviation; | |
| Result result = static_cast<Result>( | |
| d.vkGetCalibratedTimestampsEXT( m_device, | |
| timestampInfos.size(), | |
| reinterpret_cast<const VkCalibratedTimestampInfoEXT *>( timestampInfos.data() ), | |
| timestamps.data(), | |
| &maxDeviation ) ); | |
| return createResultValue( | |
| result, maxDeviation, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsEXT" ); | |
| } | |
| template <typename Uint64_tAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type | |
| Device::getCalibratedTimestampsEXT( | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT> const & timestampInfos, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t> data( | |
| std::piecewise_construct, std::forward_as_tuple( timestampInfos.size() ), std::forward_as_tuple( 0 ) ); | |
| std::vector<uint64_t, Uint64_tAllocator> & timestamps = data.first; | |
| uint64_t & maxDeviation = data.second; | |
| Result result = static_cast<Result>( | |
| d.vkGetCalibratedTimestampsEXT( m_device, | |
| timestampInfos.size(), | |
| reinterpret_cast<const VkCalibratedTimestampInfoEXT *>( timestampInfos.data() ), | |
| timestamps.data(), | |
| &maxDeviation ) ); | |
| return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsEXT" ); | |
| } | |
| template <typename Uint64_tAllocator, | |
| typename Dispatch, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, uint64_t>::value, int>::type> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type | |
| Device::getCalibratedTimestampsEXT( | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT> const & timestampInfos, | |
| Uint64_tAllocator & uint64_tAllocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t> data( | |
| std::piecewise_construct, | |
| std::forward_as_tuple( timestampInfos.size(), uint64_tAllocator ), | |
| std::forward_as_tuple( 0 ) ); | |
| std::vector<uint64_t, Uint64_tAllocator> & timestamps = data.first; | |
| uint64_t & maxDeviation = data.second; | |
| Result result = static_cast<Result>( | |
| d.vkGetCalibratedTimestampsEXT( m_device, | |
| timestampInfos.size(), | |
| reinterpret_cast<const VkCalibratedTimestampInfoEXT *>( timestampInfos.data() ), | |
| timestamps.data(), | |
| &maxDeviation ) ); | |
| return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsEXT" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_NV_mesh_shader === | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksNV( uint32_t taskCount, | |
| uint32_t firstTask, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdDrawMeshTasksNV( m_commandBuffer, taskCount, firstTask ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectNV( VULKAN_HPP_NAMESPACE::Buffer buffer, | |
| VULKAN_HPP_NAMESPACE::DeviceSize offset, | |
| uint32_t drawCount, | |
| uint32_t stride, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdDrawMeshTasksIndirectNV( | |
| m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), drawCount, stride ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::drawMeshTasksIndirectCountNV( VULKAN_HPP_NAMESPACE::Buffer buffer, | |
| VULKAN_HPP_NAMESPACE::DeviceSize offset, | |
| VULKAN_HPP_NAMESPACE::Buffer countBuffer, | |
| VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, | |
| uint32_t maxDrawCount, | |
| uint32_t stride, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdDrawMeshTasksIndirectCountNV( m_commandBuffer, | |
| static_cast<VkBuffer>( buffer ), | |
| static_cast<VkDeviceSize>( offset ), | |
| static_cast<VkBuffer>( countBuffer ), | |
| static_cast<VkDeviceSize>( countBufferOffset ), | |
| maxDrawCount, | |
| stride ); | |
| } | |
| //=== VK_NV_scissor_exclusive === | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setExclusiveScissorNV( uint32_t firstExclusiveScissor, | |
| uint32_t exclusiveScissorCount, | |
| const VULKAN_HPP_NAMESPACE::Rect2D * pExclusiveScissors, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdSetExclusiveScissorNV( m_commandBuffer, | |
| firstExclusiveScissor, | |
| exclusiveScissorCount, | |
| reinterpret_cast<const VkRect2D *>( pExclusiveScissors ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::setExclusiveScissorNV( uint32_t firstExclusiveScissor, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & exclusiveScissors, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdSetExclusiveScissorNV( m_commandBuffer, | |
| firstExclusiveScissor, | |
| exclusiveScissors.size(), | |
| reinterpret_cast<const VkRect2D *>( exclusiveScissors.data() ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_NV_device_diagnostic_checkpoints === | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setCheckpointNV( const void * pCheckpointMarker, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdSetCheckpointNV( m_commandBuffer, pCheckpointMarker ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Queue::getCheckpointDataNV( uint32_t * pCheckpointDataCount, | |
| VULKAN_HPP_NAMESPACE::CheckpointDataNV * pCheckpointData, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkGetQueueCheckpointDataNV( | |
| m_queue, pCheckpointDataCount, reinterpret_cast<VkCheckpointDataNV *>( pCheckpointData ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename CheckpointDataNVAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<CheckpointDataNV, CheckpointDataNVAllocator> | |
| Queue::getCheckpointDataNV( Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<CheckpointDataNV, CheckpointDataNVAllocator> checkpointData; | |
| uint32_t checkpointDataCount; | |
| d.vkGetQueueCheckpointDataNV( m_queue, &checkpointDataCount, nullptr ); | |
| checkpointData.resize( checkpointDataCount ); | |
| d.vkGetQueueCheckpointDataNV( | |
| m_queue, &checkpointDataCount, reinterpret_cast<VkCheckpointDataNV *>( checkpointData.data() ) ); | |
| VULKAN_HPP_ASSERT( checkpointDataCount <= checkpointData.size() ); | |
| return checkpointData; | |
| } | |
| template <typename CheckpointDataNVAllocator, | |
| typename Dispatch, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, CheckpointDataNV>::value, int>::type> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<CheckpointDataNV, CheckpointDataNVAllocator> | |
| Queue::getCheckpointDataNV( CheckpointDataNVAllocator & checkpointDataNVAllocator, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<CheckpointDataNV, CheckpointDataNVAllocator> checkpointData( checkpointDataNVAllocator ); | |
| uint32_t checkpointDataCount; | |
| d.vkGetQueueCheckpointDataNV( m_queue, &checkpointDataCount, nullptr ); | |
| checkpointData.resize( checkpointDataCount ); | |
| d.vkGetQueueCheckpointDataNV( | |
| m_queue, &checkpointDataCount, reinterpret_cast<VkCheckpointDataNV *>( checkpointData.data() ) ); | |
| VULKAN_HPP_ASSERT( checkpointDataCount <= checkpointData.size() ); | |
| return checkpointData; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_KHR_timeline_semaphore === | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSemaphoreCounterValueKHR( | |
| VULKAN_HPP_NAMESPACE::Semaphore semaphore, uint64_t * pValue, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkGetSemaphoreCounterValueKHR( m_device, static_cast<VkSemaphore>( semaphore ), pValue ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<uint64_t>::type | |
| Device::getSemaphoreCounterValueKHR( VULKAN_HPP_NAMESPACE::Semaphore semaphore, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| uint64_t value; | |
| Result result = | |
| static_cast<Result>( d.vkGetSemaphoreCounterValueKHR( m_device, static_cast<VkSemaphore>( semaphore ), &value ) ); | |
| return createResultValue( result, value, VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreCounterValueKHR" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::waitSemaphoresKHR( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo * pWaitInfo, | |
| uint64_t timeout, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkWaitSemaphoresKHR( m_device, reinterpret_cast<const VkSemaphoreWaitInfo *>( pWaitInfo ), timeout ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::waitSemaphoresKHR( const SemaphoreWaitInfo & waitInfo, | |
| uint64_t timeout, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| Result result = static_cast<Result>( | |
| d.vkWaitSemaphoresKHR( m_device, reinterpret_cast<const VkSemaphoreWaitInfo *>( &waitInfo ), timeout ) ); | |
| return createResultValue( result, | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::waitSemaphoresKHR", | |
| { 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::signalSemaphoreKHR( | |
| const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo * pSignalInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkSignalSemaphoreKHR( m_device, reinterpret_cast<const VkSemaphoreSignalInfo *>( pSignalInfo ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| Device::signalSemaphoreKHR( const SemaphoreSignalInfo & signalInfo, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| Result result = static_cast<Result>( | |
| d.vkSignalSemaphoreKHR( m_device, reinterpret_cast<const VkSemaphoreSignalInfo *>( &signalInfo ) ) ); | |
| return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::signalSemaphoreKHR" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_INTEL_performance_query === | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::initializePerformanceApiINTEL( | |
| const VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL * pInitializeInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkInitializePerformanceApiINTEL( | |
| m_device, reinterpret_cast<const VkInitializePerformanceApiInfoINTEL *>( pInitializeInfo ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| Device::initializePerformanceApiINTEL( const InitializePerformanceApiInfoINTEL & initializeInfo, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| Result result = static_cast<Result>( d.vkInitializePerformanceApiINTEL( | |
| m_device, reinterpret_cast<const VkInitializePerformanceApiInfoINTEL *>( &initializeInfo ) ) ); | |
| return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::initializePerformanceApiINTEL" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::uninitializePerformanceApiINTEL( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkUninitializePerformanceApiINTEL( m_device ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result CommandBuffer::setPerformanceMarkerINTEL( | |
| const VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL * pMarkerInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkCmdSetPerformanceMarkerINTEL( | |
| m_commandBuffer, reinterpret_cast<const VkPerformanceMarkerInfoINTEL *>( pMarkerInfo ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| CommandBuffer::setPerformanceMarkerINTEL( const PerformanceMarkerInfoINTEL & markerInfo, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| Result result = static_cast<Result>( d.vkCmdSetPerformanceMarkerINTEL( | |
| m_commandBuffer, reinterpret_cast<const VkPerformanceMarkerInfoINTEL *>( &markerInfo ) ) ); | |
| return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::setPerformanceMarkerINTEL" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result CommandBuffer::setPerformanceStreamMarkerINTEL( | |
| const VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL * pMarkerInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkCmdSetPerformanceStreamMarkerINTEL( | |
| m_commandBuffer, reinterpret_cast<const VkPerformanceStreamMarkerInfoINTEL *>( pMarkerInfo ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| CommandBuffer::setPerformanceStreamMarkerINTEL( const PerformanceStreamMarkerInfoINTEL & markerInfo, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| Result result = static_cast<Result>( d.vkCmdSetPerformanceStreamMarkerINTEL( | |
| m_commandBuffer, reinterpret_cast<const VkPerformanceStreamMarkerInfoINTEL *>( &markerInfo ) ) ); | |
| return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::setPerformanceStreamMarkerINTEL" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result CommandBuffer::setPerformanceOverrideINTEL( | |
| const VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL * pOverrideInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkCmdSetPerformanceOverrideINTEL( | |
| m_commandBuffer, reinterpret_cast<const VkPerformanceOverrideInfoINTEL *>( pOverrideInfo ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| CommandBuffer::setPerformanceOverrideINTEL( const PerformanceOverrideInfoINTEL & overrideInfo, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| Result result = static_cast<Result>( d.vkCmdSetPerformanceOverrideINTEL( | |
| m_commandBuffer, reinterpret_cast<const VkPerformanceOverrideInfoINTEL *>( &overrideInfo ) ) ); | |
| return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::setPerformanceOverrideINTEL" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::acquirePerformanceConfigurationINTEL( | |
| const VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL * pAcquireInfo, | |
| VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL * pConfiguration, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkAcquirePerformanceConfigurationINTEL( | |
| m_device, | |
| reinterpret_cast<const VkPerformanceConfigurationAcquireInfoINTEL *>( pAcquireInfo ), | |
| reinterpret_cast<VkPerformanceConfigurationINTEL *>( pConfiguration ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL>::type | |
| Device::acquirePerformanceConfigurationINTEL( const PerformanceConfigurationAcquireInfoINTEL & acquireInfo, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration; | |
| Result result = static_cast<Result>( d.vkAcquirePerformanceConfigurationINTEL( | |
| m_device, | |
| reinterpret_cast<const VkPerformanceConfigurationAcquireInfoINTEL *>( &acquireInfo ), | |
| reinterpret_cast<VkPerformanceConfigurationINTEL *>( &configuration ) ) ); | |
| return createResultValue( | |
| result, configuration, VULKAN_HPP_NAMESPACE_STRING "::Device::acquirePerformanceConfigurationINTEL" ); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL, Dispatch>>::type | |
| Device::acquirePerformanceConfigurationINTELUnique( const PerformanceConfigurationAcquireInfoINTEL & acquireInfo, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration; | |
| Result result = static_cast<Result>( d.vkAcquirePerformanceConfigurationINTEL( | |
| m_device, | |
| reinterpret_cast<const VkPerformanceConfigurationAcquireInfoINTEL *>( &acquireInfo ), | |
| reinterpret_cast<VkPerformanceConfigurationINTEL *>( &configuration ) ) ); | |
| ObjectRelease<Device, Dispatch> deleter( *this, d ); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL, Dispatch>( | |
| result, | |
| configuration, | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::acquirePerformanceConfigurationINTELUnique", | |
| deleter ); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::releasePerformanceConfigurationINTEL( | |
| VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkReleasePerformanceConfigurationINTEL( | |
| m_device, static_cast<VkPerformanceConfigurationINTEL>( configuration ) ) ); | |
| } | |
| #else | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| Device::releasePerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| Result result = static_cast<Result>( d.vkReleasePerformanceConfigurationINTEL( | |
| m_device, static_cast<VkPerformanceConfigurationINTEL>( configuration ) ) ); | |
| return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::releasePerformanceConfigurationINTEL" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::release( | |
| VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkReleasePerformanceConfigurationINTEL( | |
| m_device, static_cast<VkPerformanceConfigurationINTEL>( configuration ) ) ); | |
| } | |
| #else | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| Device::release( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| Result result = static_cast<Result>( d.vkReleasePerformanceConfigurationINTEL( | |
| m_device, static_cast<VkPerformanceConfigurationINTEL>( configuration ) ) ); | |
| return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::release" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Queue::setPerformanceConfigurationINTEL( | |
| VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkQueueSetPerformanceConfigurationINTEL( | |
| m_queue, static_cast<VkPerformanceConfigurationINTEL>( configuration ) ) ); | |
| } | |
| #else | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| Queue::setPerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| Result result = static_cast<Result>( d.vkQueueSetPerformanceConfigurationINTEL( | |
| m_queue, static_cast<VkPerformanceConfigurationINTEL>( configuration ) ) ); | |
| return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::setPerformanceConfigurationINTEL" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::getPerformanceParameterINTEL( VULKAN_HPP_NAMESPACE::PerformanceParameterTypeINTEL parameter, | |
| VULKAN_HPP_NAMESPACE::PerformanceValueINTEL * pValue, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkGetPerformanceParameterINTEL( m_device, | |
| static_cast<VkPerformanceParameterTypeINTEL>( parameter ), | |
| reinterpret_cast<VkPerformanceValueINTEL *>( pValue ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<VULKAN_HPP_NAMESPACE::PerformanceValueINTEL>::type | |
| Device::getPerformanceParameterINTEL( VULKAN_HPP_NAMESPACE::PerformanceParameterTypeINTEL parameter, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::PerformanceValueINTEL value; | |
| Result result = | |
| static_cast<Result>( d.vkGetPerformanceParameterINTEL( m_device, | |
| static_cast<VkPerformanceParameterTypeINTEL>( parameter ), | |
| reinterpret_cast<VkPerformanceValueINTEL *>( &value ) ) ); | |
| return createResultValue( result, value, VULKAN_HPP_NAMESPACE_STRING "::Device::getPerformanceParameterINTEL" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_AMD_display_native_hdr === | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::setLocalDimmingAMD( VULKAN_HPP_NAMESPACE::SwapchainKHR swapChain, | |
| VULKAN_HPP_NAMESPACE::Bool32 localDimmingEnable, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkSetLocalDimmingAMD( | |
| m_device, static_cast<VkSwapchainKHR>( swapChain ), static_cast<VkBool32>( localDimmingEnable ) ); | |
| } | |
| #if defined( VK_USE_PLATFORM_FUCHSIA ) | |
| //=== VK_FUCHSIA_imagepipe_surface === | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createImagePipeSurfaceFUCHSIA( | |
| const VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA * pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkCreateImagePipeSurfaceFUCHSIA( m_instance, | |
| reinterpret_cast<const VkImagePipeSurfaceCreateInfoFUCHSIA *>( pCreateInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), | |
| reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) ); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type | |
| Instance::createImagePipeSurfaceFUCHSIA( const ImagePipeSurfaceCreateInfoFUCHSIA & createInfo, | |
| Optional<const 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.vkCreateImagePipeSurfaceFUCHSIA( | |
| m_instance, | |
| reinterpret_cast<const VkImagePipeSurfaceCreateInfoFUCHSIA *>( &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::createImagePipeSurfaceFUCHSIA" ); | |
| } | |
| # 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::createImagePipeSurfaceFUCHSIAUnique( const ImagePipeSurfaceCreateInfoFUCHSIA & createInfo, | |
| Optional<const 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.vkCreateImagePipeSurfaceFUCHSIA( | |
| m_instance, | |
| reinterpret_cast<const VkImagePipeSurfaceCreateInfoFUCHSIA *>( &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::createImagePipeSurfaceFUCHSIAUnique", deleter ); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #endif /*VK_USE_PLATFORM_FUCHSIA*/ | |
| #if defined( VK_USE_PLATFORM_METAL_EXT ) | |
| //=== VK_EXT_metal_surface === | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Instance::createMetalSurfaceEXT( const VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT * pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkCreateMetalSurfaceEXT( m_instance, | |
| reinterpret_cast<const VkMetalSurfaceCreateInfoEXT *>( pCreateInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), | |
| reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) ); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type | |
| Instance::createMetalSurfaceEXT( const MetalSurfaceCreateInfoEXT & createInfo, | |
| Optional<const 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.vkCreateMetalSurfaceEXT( m_instance, | |
| reinterpret_cast<const VkMetalSurfaceCreateInfoEXT *>( &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::createMetalSurfaceEXT" ); | |
| } | |
| # 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::createMetalSurfaceEXTUnique( const MetalSurfaceCreateInfoEXT & createInfo, | |
| Optional<const 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.vkCreateMetalSurfaceEXT( m_instance, | |
| reinterpret_cast<const VkMetalSurfaceCreateInfoEXT *>( &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::createMetalSurfaceEXTUnique", deleter ); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #endif /*VK_USE_PLATFORM_METAL_EXT*/ | |
| //=== VK_KHR_fragment_shading_rate === | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getFragmentShadingRatesKHR( | |
| uint32_t * pFragmentShadingRateCount, | |
| VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR * pFragmentShadingRates, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkGetPhysicalDeviceFragmentShadingRatesKHR( | |
| m_physicalDevice, | |
| pFragmentShadingRateCount, | |
| reinterpret_cast<VkPhysicalDeviceFragmentShadingRateKHR *>( pFragmentShadingRates ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename PhysicalDeviceFragmentShadingRateKHRAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType< | |
| std::vector<PhysicalDeviceFragmentShadingRateKHR, PhysicalDeviceFragmentShadingRateKHRAllocator>>::type | |
| PhysicalDevice::getFragmentShadingRatesKHR( Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<PhysicalDeviceFragmentShadingRateKHR, PhysicalDeviceFragmentShadingRateKHRAllocator> | |
| fragmentShadingRates; | |
| uint32_t fragmentShadingRateCount; | |
| Result result; | |
| do | |
| { | |
| result = static_cast<Result>( | |
| d.vkGetPhysicalDeviceFragmentShadingRatesKHR( m_physicalDevice, &fragmentShadingRateCount, nullptr ) ); | |
| if ( ( result == Result::eSuccess ) && fragmentShadingRateCount ) | |
| { | |
| fragmentShadingRates.resize( fragmentShadingRateCount ); | |
| result = static_cast<Result>( d.vkGetPhysicalDeviceFragmentShadingRatesKHR( | |
| m_physicalDevice, | |
| &fragmentShadingRateCount, | |
| reinterpret_cast<VkPhysicalDeviceFragmentShadingRateKHR *>( fragmentShadingRates.data() ) ) ); | |
| VULKAN_HPP_ASSERT( fragmentShadingRateCount <= fragmentShadingRates.size() ); | |
| } | |
| } while ( result == Result::eIncomplete ); | |
| if ( ( result == Result::eSuccess ) && ( fragmentShadingRateCount < fragmentShadingRates.size() ) ) | |
| { | |
| fragmentShadingRates.resize( fragmentShadingRateCount ); | |
| } | |
| return createResultValue( | |
| result, fragmentShadingRates, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getFragmentShadingRatesKHR" ); | |
| } | |
| template <typename PhysicalDeviceFragmentShadingRateKHRAllocator, | |
| typename Dispatch, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, PhysicalDeviceFragmentShadingRateKHR>::value, | |
| int>::type> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType< | |
| std::vector<PhysicalDeviceFragmentShadingRateKHR, PhysicalDeviceFragmentShadingRateKHRAllocator>>::type | |
| PhysicalDevice::getFragmentShadingRatesKHR( | |
| PhysicalDeviceFragmentShadingRateKHRAllocator & physicalDeviceFragmentShadingRateKHRAllocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<PhysicalDeviceFragmentShadingRateKHR, PhysicalDeviceFragmentShadingRateKHRAllocator> | |
| fragmentShadingRates( physicalDeviceFragmentShadingRateKHRAllocator ); | |
| uint32_t fragmentShadingRateCount; | |
| Result result; | |
| do | |
| { | |
| result = static_cast<Result>( | |
| d.vkGetPhysicalDeviceFragmentShadingRatesKHR( m_physicalDevice, &fragmentShadingRateCount, nullptr ) ); | |
| if ( ( result == Result::eSuccess ) && fragmentShadingRateCount ) | |
| { | |
| fragmentShadingRates.resize( fragmentShadingRateCount ); | |
| result = static_cast<Result>( d.vkGetPhysicalDeviceFragmentShadingRatesKHR( | |
| m_physicalDevice, | |
| &fragmentShadingRateCount, | |
| reinterpret_cast<VkPhysicalDeviceFragmentShadingRateKHR *>( fragmentShadingRates.data() ) ) ); | |
| VULKAN_HPP_ASSERT( fragmentShadingRateCount <= fragmentShadingRates.size() ); | |
| } | |
| } while ( result == Result::eIncomplete ); | |
| if ( ( result == Result::eSuccess ) && ( fragmentShadingRateCount < fragmentShadingRates.size() ) ) | |
| { | |
| fragmentShadingRates.resize( fragmentShadingRateCount ); | |
| } | |
| return createResultValue( | |
| result, fragmentShadingRates, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getFragmentShadingRatesKHR" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setFragmentShadingRateKHR( | |
| const VULKAN_HPP_NAMESPACE::Extent2D * pFragmentSize, | |
| const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2], | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdSetFragmentShadingRateKHR( m_commandBuffer, | |
| reinterpret_cast<const VkExtent2D *>( pFragmentSize ), | |
| reinterpret_cast<const VkFragmentShadingRateCombinerOpKHR *>( combinerOps ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setFragmentShadingRateKHR( | |
| const Extent2D & fragmentSize, | |
| const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2], | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdSetFragmentShadingRateKHR( m_commandBuffer, | |
| reinterpret_cast<const VkExtent2D *>( &fragmentSize ), | |
| reinterpret_cast<const VkFragmentShadingRateCombinerOpKHR *>( combinerOps ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_EXT_buffer_device_address === | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddressEXT( | |
| const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<DeviceAddress>( | |
| d.vkGetBufferDeviceAddressEXT( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo *>( pInfo ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddressEXT( const BufferDeviceAddressInfo & info, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return d.vkGetBufferDeviceAddressEXT( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo *>( &info ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_EXT_tooling_info === | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| PhysicalDevice::getToolPropertiesEXT( uint32_t * pToolCount, | |
| VULKAN_HPP_NAMESPACE::PhysicalDeviceToolPropertiesEXT * pToolProperties, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkGetPhysicalDeviceToolPropertiesEXT( | |
| m_physicalDevice, pToolCount, reinterpret_cast<VkPhysicalDeviceToolPropertiesEXT *>( pToolProperties ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename PhysicalDeviceToolPropertiesEXTAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType< | |
| std::vector<PhysicalDeviceToolPropertiesEXT, PhysicalDeviceToolPropertiesEXTAllocator>>::type | |
| PhysicalDevice::getToolPropertiesEXT( Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<PhysicalDeviceToolPropertiesEXT, PhysicalDeviceToolPropertiesEXTAllocator> toolProperties; | |
| uint32_t toolCount; | |
| Result result; | |
| do | |
| { | |
| result = static_cast<Result>( d.vkGetPhysicalDeviceToolPropertiesEXT( m_physicalDevice, &toolCount, nullptr ) ); | |
| if ( ( result == Result::eSuccess ) && toolCount ) | |
| { | |
| toolProperties.resize( toolCount ); | |
| result = static_cast<Result>( d.vkGetPhysicalDeviceToolPropertiesEXT( | |
| m_physicalDevice, | |
| &toolCount, | |
| reinterpret_cast<VkPhysicalDeviceToolPropertiesEXT *>( toolProperties.data() ) ) ); | |
| VULKAN_HPP_ASSERT( toolCount <= toolProperties.size() ); | |
| } | |
| } while ( result == Result::eIncomplete ); | |
| if ( ( result == Result::eSuccess ) && ( toolCount < toolProperties.size() ) ) | |
| { | |
| toolProperties.resize( toolCount ); | |
| } | |
| return createResultValue( | |
| result, toolProperties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getToolPropertiesEXT" ); | |
| } | |
| template < | |
| typename PhysicalDeviceToolPropertiesEXTAllocator, | |
| typename Dispatch, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, PhysicalDeviceToolPropertiesEXT>::value, int>::type> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType< | |
| std::vector<PhysicalDeviceToolPropertiesEXT, PhysicalDeviceToolPropertiesEXTAllocator>>::type | |
| PhysicalDevice::getToolPropertiesEXT( | |
| PhysicalDeviceToolPropertiesEXTAllocator & physicalDeviceToolPropertiesEXTAllocator, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<PhysicalDeviceToolPropertiesEXT, PhysicalDeviceToolPropertiesEXTAllocator> toolProperties( | |
| physicalDeviceToolPropertiesEXTAllocator ); | |
| uint32_t toolCount; | |
| Result result; | |
| do | |
| { | |
| result = static_cast<Result>( d.vkGetPhysicalDeviceToolPropertiesEXT( m_physicalDevice, &toolCount, nullptr ) ); | |
| if ( ( result == Result::eSuccess ) && toolCount ) | |
| { | |
| toolProperties.resize( toolCount ); | |
| result = static_cast<Result>( d.vkGetPhysicalDeviceToolPropertiesEXT( | |
| m_physicalDevice, | |
| &toolCount, | |
| reinterpret_cast<VkPhysicalDeviceToolPropertiesEXT *>( toolProperties.data() ) ) ); | |
| VULKAN_HPP_ASSERT( toolCount <= toolProperties.size() ); | |
| } | |
| } while ( result == Result::eIncomplete ); | |
| if ( ( result == Result::eSuccess ) && ( toolCount < toolProperties.size() ) ) | |
| { | |
| toolProperties.resize( toolCount ); | |
| } | |
| return createResultValue( | |
| result, toolProperties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getToolPropertiesEXT" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_KHR_present_wait === | |
| #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::waitForPresentKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, | |
| uint64_t presentId, | |
| uint64_t timeout, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkWaitForPresentKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), presentId, timeout ) ); | |
| } | |
| #else | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::waitForPresentKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, | |
| uint64_t presentId, | |
| uint64_t timeout, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| Result result = static_cast<Result>( | |
| d.vkWaitForPresentKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), presentId, timeout ) ); | |
| return createResultValue( result, | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::waitForPresentKHR", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eTimeout } ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_NV_cooperative_matrix === | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| PhysicalDevice::getCooperativeMatrixPropertiesNV( uint32_t * pPropertyCount, | |
| VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV * pProperties, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( | |
| m_physicalDevice, pPropertyCount, reinterpret_cast<VkCooperativeMatrixPropertiesNV *>( pProperties ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename CooperativeMatrixPropertiesNVAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE | |
| typename ResultValueType<std::vector<CooperativeMatrixPropertiesNV, CooperativeMatrixPropertiesNVAllocator>>::type | |
| PhysicalDevice::getCooperativeMatrixPropertiesNV( Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<CooperativeMatrixPropertiesNV, CooperativeMatrixPropertiesNVAllocator> properties; | |
| uint32_t propertyCount; | |
| Result result; | |
| do | |
| { | |
| result = static_cast<Result>( | |
| d.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( m_physicalDevice, &propertyCount, nullptr ) ); | |
| if ( ( result == Result::eSuccess ) && propertyCount ) | |
| { | |
| properties.resize( propertyCount ); | |
| result = static_cast<Result>( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( | |
| m_physicalDevice, | |
| &propertyCount, | |
| reinterpret_cast<VkCooperativeMatrixPropertiesNV *>( 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::getCooperativeMatrixPropertiesNV" ); | |
| } | |
| template < | |
| typename CooperativeMatrixPropertiesNVAllocator, | |
| typename Dispatch, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, CooperativeMatrixPropertiesNV>::value, int>::type> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE | |
| typename ResultValueType<std::vector<CooperativeMatrixPropertiesNV, CooperativeMatrixPropertiesNVAllocator>>::type | |
| PhysicalDevice::getCooperativeMatrixPropertiesNV( | |
| CooperativeMatrixPropertiesNVAllocator & cooperativeMatrixPropertiesNVAllocator, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<CooperativeMatrixPropertiesNV, CooperativeMatrixPropertiesNVAllocator> properties( | |
| cooperativeMatrixPropertiesNVAllocator ); | |
| uint32_t propertyCount; | |
| Result result; | |
| do | |
| { | |
| result = static_cast<Result>( | |
| d.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( m_physicalDevice, &propertyCount, nullptr ) ); | |
| if ( ( result == Result::eSuccess ) && propertyCount ) | |
| { | |
| properties.resize( propertyCount ); | |
| result = static_cast<Result>( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( | |
| m_physicalDevice, | |
| &propertyCount, | |
| reinterpret_cast<VkCooperativeMatrixPropertiesNV *>( 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::getCooperativeMatrixPropertiesNV" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_NV_coverage_reduction_mode === | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV( | |
| uint32_t * pCombinationCount, | |
| VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV * pCombinations, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( | |
| m_physicalDevice, | |
| pCombinationCount, | |
| reinterpret_cast<VkFramebufferMixedSamplesCombinationNV *>( pCombinations ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename FramebufferMixedSamplesCombinationNVAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType< | |
| std::vector<FramebufferMixedSamplesCombinationNV, FramebufferMixedSamplesCombinationNVAllocator>>::type | |
| PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV( Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<FramebufferMixedSamplesCombinationNV, FramebufferMixedSamplesCombinationNVAllocator> combinations; | |
| uint32_t combinationCount; | |
| Result result; | |
| do | |
| { | |
| result = static_cast<Result>( d.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( | |
| m_physicalDevice, &combinationCount, nullptr ) ); | |
| if ( ( result == Result::eSuccess ) && combinationCount ) | |
| { | |
| combinations.resize( combinationCount ); | |
| result = static_cast<Result>( d.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( | |
| m_physicalDevice, | |
| &combinationCount, | |
| reinterpret_cast<VkFramebufferMixedSamplesCombinationNV *>( combinations.data() ) ) ); | |
| VULKAN_HPP_ASSERT( combinationCount <= combinations.size() ); | |
| } | |
| } while ( result == Result::eIncomplete ); | |
| if ( ( result == Result::eSuccess ) && ( combinationCount < combinations.size() ) ) | |
| { | |
| combinations.resize( combinationCount ); | |
| } | |
| return createResultValue( result, | |
| combinations, | |
| VULKAN_HPP_NAMESPACE_STRING | |
| "::PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV" ); | |
| } | |
| template <typename FramebufferMixedSamplesCombinationNVAllocator, | |
| typename Dispatch, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, FramebufferMixedSamplesCombinationNV>::value, | |
| int>::type> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType< | |
| std::vector<FramebufferMixedSamplesCombinationNV, FramebufferMixedSamplesCombinationNVAllocator>>::type | |
| PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV( | |
| FramebufferMixedSamplesCombinationNVAllocator & framebufferMixedSamplesCombinationNVAllocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<FramebufferMixedSamplesCombinationNV, FramebufferMixedSamplesCombinationNVAllocator> combinations( | |
| framebufferMixedSamplesCombinationNVAllocator ); | |
| uint32_t combinationCount; | |
| Result result; | |
| do | |
| { | |
| result = static_cast<Result>( d.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( | |
| m_physicalDevice, &combinationCount, nullptr ) ); | |
| if ( ( result == Result::eSuccess ) && combinationCount ) | |
| { | |
| combinations.resize( combinationCount ); | |
| result = static_cast<Result>( d.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( | |
| m_physicalDevice, | |
| &combinationCount, | |
| reinterpret_cast<VkFramebufferMixedSamplesCombinationNV *>( combinations.data() ) ) ); | |
| VULKAN_HPP_ASSERT( combinationCount <= combinations.size() ); | |
| } | |
| } while ( result == Result::eIncomplete ); | |
| if ( ( result == Result::eSuccess ) && ( combinationCount < combinations.size() ) ) | |
| { | |
| combinations.resize( combinationCount ); | |
| } | |
| return createResultValue( result, | |
| combinations, | |
| VULKAN_HPP_NAMESPACE_STRING | |
| "::PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #if defined( VK_USE_PLATFORM_WIN32_KHR ) | |
| //=== VK_EXT_full_screen_exclusive === | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getSurfacePresentModes2EXT( | |
| const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo, | |
| uint32_t * pPresentModeCount, | |
| VULKAN_HPP_NAMESPACE::PresentModeKHR * pPresentModes, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkGetPhysicalDeviceSurfacePresentModes2EXT( | |
| m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( pSurfaceInfo ), | |
| pPresentModeCount, | |
| reinterpret_cast<VkPresentModeKHR *>( pPresentModes ) ) ); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename PresentModeKHRAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE | |
| typename ResultValueType<std::vector<PresentModeKHR, PresentModeKHRAllocator>>::type | |
| PhysicalDevice::getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, | |
| 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.vkGetPhysicalDeviceSurfacePresentModes2EXT( | |
| m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ), | |
| &presentModeCount, | |
| nullptr ) ); | |
| if ( ( result == Result::eSuccess ) && presentModeCount ) | |
| { | |
| presentModes.resize( presentModeCount ); | |
| result = static_cast<Result>( d.vkGetPhysicalDeviceSurfacePresentModes2EXT( | |
| m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ), | |
| &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::getSurfacePresentModes2EXT" ); | |
| } | |
| 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::getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, | |
| 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.vkGetPhysicalDeviceSurfacePresentModes2EXT( | |
| m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ), | |
| &presentModeCount, | |
| nullptr ) ); | |
| if ( ( result == Result::eSuccess ) && presentModeCount ) | |
| { | |
| presentModes.resize( presentModeCount ); | |
| result = static_cast<Result>( d.vkGetPhysicalDeviceSurfacePresentModes2EXT( | |
| m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ), | |
| &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::getSurfacePresentModes2EXT" ); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| # ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::acquireFullScreenExclusiveModeEXT( | |
| VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkAcquireFullScreenExclusiveModeEXT( m_device, static_cast<VkSwapchainKHR>( swapchain ) ) ); | |
| } | |
| # else | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| Device::acquireFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| Result result = static_cast<Result>( | |
| d.vkAcquireFullScreenExclusiveModeEXT( m_device, static_cast<VkSwapchainKHR>( swapchain ) ) ); | |
| return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::acquireFullScreenExclusiveModeEXT" ); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| # ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::releaseFullScreenExclusiveModeEXT( | |
| VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkReleaseFullScreenExclusiveModeEXT( m_device, static_cast<VkSwapchainKHR>( swapchain ) ) ); | |
| } | |
| # else | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| Device::releaseFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| Result result = static_cast<Result>( | |
| d.vkReleaseFullScreenExclusiveModeEXT( m_device, static_cast<VkSwapchainKHR>( swapchain ) ) ); | |
| return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::releaseFullScreenExclusiveModeEXT" ); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::getGroupSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo, | |
| VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR * pModes, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkGetDeviceGroupSurfacePresentModes2EXT( | |
| m_device, | |
| reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( pSurfaceInfo ), | |
| reinterpret_cast<VkDeviceGroupPresentModeFlagsKHR *>( pModes ) ) ); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR>::type | |
| Device::getGroupSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR modes; | |
| Result result = static_cast<Result>( d.vkGetDeviceGroupSurfacePresentModes2EXT( | |
| m_device, | |
| reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ), | |
| reinterpret_cast<VkDeviceGroupPresentModeFlagsKHR *>( &modes ) ) ); | |
| return createResultValue( result, modes, VULKAN_HPP_NAMESPACE_STRING "::Device::getGroupSurfacePresentModes2EXT" ); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #endif /*VK_USE_PLATFORM_WIN32_KHR*/ | |
| //=== VK_EXT_headless_surface === | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Instance::createHeadlessSurfaceEXT( const VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT * pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkCreateHeadlessSurfaceEXT( m_instance, | |
| reinterpret_cast<const VkHeadlessSurfaceCreateInfoEXT *>( pCreateInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), | |
| reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type | |
| Instance::createHeadlessSurfaceEXT( const HeadlessSurfaceCreateInfoEXT & createInfo, | |
| Optional<const 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.vkCreateHeadlessSurfaceEXT( m_instance, | |
| reinterpret_cast<const VkHeadlessSurfaceCreateInfoEXT *>( &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::createHeadlessSurfaceEXT" ); | |
| } | |
| # 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::createHeadlessSurfaceEXTUnique( const HeadlessSurfaceCreateInfoEXT & createInfo, | |
| Optional<const 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.vkCreateHeadlessSurfaceEXT( m_instance, | |
| reinterpret_cast<const VkHeadlessSurfaceCreateInfoEXT *>( &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::createHeadlessSurfaceEXTUnique", deleter ); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_KHR_buffer_device_address === | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddressKHR( | |
| const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<DeviceAddress>( | |
| d.vkGetBufferDeviceAddressKHR( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo *>( pInfo ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddressKHR( const BufferDeviceAddressInfo & info, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return d.vkGetBufferDeviceAddressKHR( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo *>( &info ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE uint64_t Device::getBufferOpaqueCaptureAddressKHR( | |
| const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return d.vkGetBufferOpaqueCaptureAddressKHR( m_device, | |
| reinterpret_cast<const VkBufferDeviceAddressInfo *>( pInfo ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE uint64_t Device::getBufferOpaqueCaptureAddressKHR( const BufferDeviceAddressInfo & info, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return d.vkGetBufferOpaqueCaptureAddressKHR( m_device, | |
| reinterpret_cast<const VkBufferDeviceAddressInfo *>( &info ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE uint64_t | |
| Device::getMemoryOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo * pInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return d.vkGetDeviceMemoryOpaqueCaptureAddressKHR( | |
| m_device, reinterpret_cast<const VkDeviceMemoryOpaqueCaptureAddressInfo *>( pInfo ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE uint64_t Device::getMemoryOpaqueCaptureAddressKHR( | |
| const DeviceMemoryOpaqueCaptureAddressInfo & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return d.vkGetDeviceMemoryOpaqueCaptureAddressKHR( | |
| m_device, reinterpret_cast<const VkDeviceMemoryOpaqueCaptureAddressInfo *>( &info ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_EXT_line_rasterization === | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setLineStippleEXT( uint32_t lineStippleFactor, | |
| uint16_t lineStipplePattern, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdSetLineStippleEXT( m_commandBuffer, lineStippleFactor, lineStipplePattern ); | |
| } | |
| //=== VK_EXT_host_query_reset === | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::resetQueryPoolEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool, | |
| uint32_t firstQuery, | |
| uint32_t queryCount, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkResetQueryPoolEXT( m_device, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount ); | |
| } | |
| //=== VK_EXT_extended_dynamic_state === | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setCullModeEXT( VULKAN_HPP_NAMESPACE::CullModeFlags cullMode, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdSetCullModeEXT( m_commandBuffer, static_cast<VkCullModeFlags>( cullMode ) ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setFrontFaceEXT( VULKAN_HPP_NAMESPACE::FrontFace frontFace, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdSetFrontFaceEXT( m_commandBuffer, static_cast<VkFrontFace>( frontFace ) ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::setPrimitiveTopologyEXT( VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdSetPrimitiveTopologyEXT( m_commandBuffer, static_cast<VkPrimitiveTopology>( primitiveTopology ) ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setViewportWithCountEXT( uint32_t viewportCount, | |
| const VULKAN_HPP_NAMESPACE::Viewport * pViewports, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdSetViewportWithCountEXT( | |
| m_commandBuffer, viewportCount, reinterpret_cast<const VkViewport *>( pViewports ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::setViewportWithCountEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdSetViewportWithCountEXT( | |
| m_commandBuffer, viewports.size(), reinterpret_cast<const VkViewport *>( viewports.data() ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setScissorWithCountEXT( uint32_t scissorCount, | |
| const VULKAN_HPP_NAMESPACE::Rect2D * pScissors, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdSetScissorWithCountEXT( m_commandBuffer, scissorCount, reinterpret_cast<const VkRect2D *>( pScissors ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::setScissorWithCountEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdSetScissorWithCountEXT( | |
| m_commandBuffer, scissors.size(), reinterpret_cast<const VkRect2D *>( scissors.data() ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers2EXT( uint32_t firstBinding, | |
| uint32_t bindingCount, | |
| const VULKAN_HPP_NAMESPACE::Buffer * pBuffers, | |
| const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets, | |
| const VULKAN_HPP_NAMESPACE::DeviceSize * pSizes, | |
| const VULKAN_HPP_NAMESPACE::DeviceSize * pStrides, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdBindVertexBuffers2EXT( m_commandBuffer, | |
| firstBinding, | |
| bindingCount, | |
| reinterpret_cast<const VkBuffer *>( pBuffers ), | |
| reinterpret_cast<const VkDeviceSize *>( pOffsets ), | |
| reinterpret_cast<const VkDeviceSize *>( pSizes ), | |
| reinterpret_cast<const VkDeviceSize *>( pStrides ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::bindVertexBuffers2EXT( uint32_t firstBinding, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & strides, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| # ifdef VULKAN_HPP_NO_EXCEPTIONS | |
| VULKAN_HPP_ASSERT( buffers.size() == offsets.size() ); | |
| VULKAN_HPP_ASSERT( sizes.empty() || buffers.size() == sizes.size() ); | |
| VULKAN_HPP_ASSERT( strides.empty() || buffers.size() == strides.size() ); | |
| # else | |
| if ( buffers.size() != offsets.size() ) | |
| { | |
| throw LogicError( VULKAN_HPP_NAMESPACE_STRING | |
| "::CommandBuffer::bindVertexBuffers2EXT: buffers.size() != offsets.size()" ); | |
| } | |
| if ( !sizes.empty() && buffers.size() != sizes.size() ) | |
| { | |
| throw LogicError( VULKAN_HPP_NAMESPACE_STRING | |
| "::CommandBuffer::bindVertexBuffers2EXT: buffers.size() != sizes.size()" ); | |
| } | |
| if ( !strides.empty() && buffers.size() != strides.size() ) | |
| { | |
| throw LogicError( VULKAN_HPP_NAMESPACE_STRING | |
| "::CommandBuffer::bindVertexBuffers2EXT: buffers.size() != strides.size()" ); | |
| } | |
| # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ | |
| d.vkCmdBindVertexBuffers2EXT( m_commandBuffer, | |
| firstBinding, | |
| buffers.size(), | |
| reinterpret_cast<const VkBuffer *>( buffers.data() ), | |
| reinterpret_cast<const VkDeviceSize *>( offsets.data() ), | |
| reinterpret_cast<const VkDeviceSize *>( sizes.data() ), | |
| reinterpret_cast<const VkDeviceSize *>( strides.data() ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setDepthTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdSetDepthTestEnableEXT( m_commandBuffer, static_cast<VkBool32>( depthTestEnable ) ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setDepthWriteEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdSetDepthWriteEnableEXT( m_commandBuffer, static_cast<VkBool32>( depthWriteEnable ) ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setDepthCompareOpEXT( VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdSetDepthCompareOpEXT( m_commandBuffer, static_cast<VkCompareOp>( depthCompareOp ) ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setDepthBoundsTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdSetDepthBoundsTestEnableEXT( m_commandBuffer, static_cast<VkBool32>( depthBoundsTestEnable ) ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setStencilTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdSetStencilTestEnableEXT( m_commandBuffer, static_cast<VkBool32>( stencilTestEnable ) ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setStencilOpEXT( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, | |
| VULKAN_HPP_NAMESPACE::StencilOp failOp, | |
| VULKAN_HPP_NAMESPACE::StencilOp passOp, | |
| VULKAN_HPP_NAMESPACE::StencilOp depthFailOp, | |
| VULKAN_HPP_NAMESPACE::CompareOp compareOp, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdSetStencilOpEXT( m_commandBuffer, | |
| static_cast<VkStencilFaceFlags>( faceMask ), | |
| static_cast<VkStencilOp>( failOp ), | |
| static_cast<VkStencilOp>( passOp ), | |
| static_cast<VkStencilOp>( depthFailOp ), | |
| static_cast<VkCompareOp>( compareOp ) ); | |
| } | |
| //=== VK_KHR_deferred_host_operations === | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::createDeferredOperationKHR( const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| VULKAN_HPP_NAMESPACE::DeferredOperationKHR * pDeferredOperation, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkCreateDeferredOperationKHR( m_device, | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), | |
| reinterpret_cast<VkDeferredOperationKHR *>( pDeferredOperation ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::DeferredOperationKHR>::type | |
| Device::createDeferredOperationKHR( Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation; | |
| Result result = static_cast<Result>( | |
| d.vkCreateDeferredOperationKHR( m_device, | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkDeferredOperationKHR *>( &deferredOperation ) ) ); | |
| return createResultValue( | |
| result, deferredOperation, VULKAN_HPP_NAMESPACE_STRING "::Device::createDeferredOperationKHR" ); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DeferredOperationKHR, Dispatch>>::type | |
| Device::createDeferredOperationKHRUnique( Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation; | |
| Result result = static_cast<Result>( | |
| d.vkCreateDeferredOperationKHR( m_device, | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkDeferredOperationKHR *>( &deferredOperation ) ) ); | |
| ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d ); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::DeferredOperationKHR, Dispatch>( | |
| result, deferredOperation, VULKAN_HPP_NAMESPACE_STRING "::Device::createDeferredOperationKHRUnique", deleter ); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| Device::destroyDeferredOperationKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyDeferredOperationKHR( m_device, | |
| static_cast<VkDeferredOperationKHR>( operation ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroyDeferredOperationKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, | |
| Optional<const AllocationCallbacks> allocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyDeferredOperationKHR( m_device, | |
| static_cast<VkDeferredOperationKHR>( operation ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyDeferredOperationKHR( m_device, | |
| static_cast<VkDeferredOperationKHR>( operation ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, | |
| Optional<const AllocationCallbacks> allocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyDeferredOperationKHR( m_device, | |
| static_cast<VkDeferredOperationKHR>( operation ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE uint32_t Device::getDeferredOperationMaxConcurrencyKHR( | |
| VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return d.vkGetDeferredOperationMaxConcurrencyKHR( m_device, static_cast<VkDeferredOperationKHR>( operation ) ); | |
| } | |
| #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getDeferredOperationResultKHR( | |
| VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkGetDeferredOperationResultKHR( m_device, static_cast<VkDeferredOperationKHR>( operation ) ) ); | |
| } | |
| #else | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getDeferredOperationResultKHR( | |
| VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| Result result = static_cast<Result>( | |
| d.vkGetDeferredOperationResultKHR( m_device, static_cast<VkDeferredOperationKHR>( operation ) ) ); | |
| return createResultValue( result, | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::getDeferredOperationResultKHR", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eNotReady } ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::deferredOperationJoinKHR( | |
| VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkDeferredOperationJoinKHR( m_device, static_cast<VkDeferredOperationKHR>( operation ) ) ); | |
| } | |
| #else | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::deferredOperationJoinKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| Result result = | |
| static_cast<Result>( d.vkDeferredOperationJoinKHR( m_device, static_cast<VkDeferredOperationKHR>( operation ) ) ); | |
| return createResultValue( result, | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::deferredOperationJoinKHR", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, | |
| VULKAN_HPP_NAMESPACE::Result::eThreadDoneKHR, | |
| VULKAN_HPP_NAMESPACE::Result::eThreadIdleKHR } ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_KHR_pipeline_executable_properties === | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::getPipelineExecutablePropertiesKHR( const VULKAN_HPP_NAMESPACE::PipelineInfoKHR * pPipelineInfo, | |
| uint32_t * pExecutableCount, | |
| VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR * pProperties, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkGetPipelineExecutablePropertiesKHR( m_device, | |
| reinterpret_cast<const VkPipelineInfoKHR *>( pPipelineInfo ), | |
| pExecutableCount, | |
| reinterpret_cast<VkPipelineExecutablePropertiesKHR *>( pProperties ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename PipelineExecutablePropertiesKHRAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType< | |
| std::vector<PipelineExecutablePropertiesKHR, PipelineExecutablePropertiesKHRAllocator>>::type | |
| Device::getPipelineExecutablePropertiesKHR( const PipelineInfoKHR & pipelineInfo, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<PipelineExecutablePropertiesKHR, PipelineExecutablePropertiesKHRAllocator> properties; | |
| uint32_t executableCount; | |
| Result result; | |
| do | |
| { | |
| result = static_cast<Result>( d.vkGetPipelineExecutablePropertiesKHR( | |
| m_device, reinterpret_cast<const VkPipelineInfoKHR *>( &pipelineInfo ), &executableCount, nullptr ) ); | |
| if ( ( result == Result::eSuccess ) && executableCount ) | |
| { | |
| properties.resize( executableCount ); | |
| result = static_cast<Result>( d.vkGetPipelineExecutablePropertiesKHR( | |
| m_device, | |
| reinterpret_cast<const VkPipelineInfoKHR *>( &pipelineInfo ), | |
| &executableCount, | |
| reinterpret_cast<VkPipelineExecutablePropertiesKHR *>( properties.data() ) ) ); | |
| VULKAN_HPP_ASSERT( executableCount <= properties.size() ); | |
| } | |
| } while ( result == Result::eIncomplete ); | |
| if ( ( result == Result::eSuccess ) && ( executableCount < properties.size() ) ) | |
| { | |
| properties.resize( executableCount ); | |
| } | |
| return createResultValue( | |
| result, properties, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineExecutablePropertiesKHR" ); | |
| } | |
| template < | |
| typename PipelineExecutablePropertiesKHRAllocator, | |
| typename Dispatch, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, PipelineExecutablePropertiesKHR>::value, int>::type> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType< | |
| std::vector<PipelineExecutablePropertiesKHR, PipelineExecutablePropertiesKHRAllocator>>::type | |
| Device::getPipelineExecutablePropertiesKHR( | |
| const PipelineInfoKHR & pipelineInfo, | |
| PipelineExecutablePropertiesKHRAllocator & pipelineExecutablePropertiesKHRAllocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<PipelineExecutablePropertiesKHR, PipelineExecutablePropertiesKHRAllocator> properties( | |
| pipelineExecutablePropertiesKHRAllocator ); | |
| uint32_t executableCount; | |
| Result result; | |
| do | |
| { | |
| result = static_cast<Result>( d.vkGetPipelineExecutablePropertiesKHR( | |
| m_device, reinterpret_cast<const VkPipelineInfoKHR *>( &pipelineInfo ), &executableCount, nullptr ) ); | |
| if ( ( result == Result::eSuccess ) && executableCount ) | |
| { | |
| properties.resize( executableCount ); | |
| result = static_cast<Result>( d.vkGetPipelineExecutablePropertiesKHR( | |
| m_device, | |
| reinterpret_cast<const VkPipelineInfoKHR *>( &pipelineInfo ), | |
| &executableCount, | |
| reinterpret_cast<VkPipelineExecutablePropertiesKHR *>( properties.data() ) ) ); | |
| VULKAN_HPP_ASSERT( executableCount <= properties.size() ); | |
| } | |
| } while ( result == Result::eIncomplete ); | |
| if ( ( result == Result::eSuccess ) && ( executableCount < properties.size() ) ) | |
| { | |
| properties.resize( executableCount ); | |
| } | |
| return createResultValue( | |
| result, properties, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineExecutablePropertiesKHR" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::getPipelineExecutableStatisticsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR * pExecutableInfo, | |
| uint32_t * pStatisticCount, | |
| VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR * pStatistics, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkGetPipelineExecutableStatisticsKHR( m_device, | |
| reinterpret_cast<const VkPipelineExecutableInfoKHR *>( pExecutableInfo ), | |
| pStatisticCount, | |
| reinterpret_cast<VkPipelineExecutableStatisticKHR *>( pStatistics ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename PipelineExecutableStatisticKHRAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE | |
| typename ResultValueType<std::vector<PipelineExecutableStatisticKHR, PipelineExecutableStatisticKHRAllocator>>::type | |
| Device::getPipelineExecutableStatisticsKHR( const PipelineExecutableInfoKHR & executableInfo, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<PipelineExecutableStatisticKHR, PipelineExecutableStatisticKHRAllocator> statistics; | |
| uint32_t statisticCount; | |
| Result result; | |
| do | |
| { | |
| result = static_cast<Result>( d.vkGetPipelineExecutableStatisticsKHR( | |
| m_device, | |
| reinterpret_cast<const VkPipelineExecutableInfoKHR *>( &executableInfo ), | |
| &statisticCount, | |
| nullptr ) ); | |
| if ( ( result == Result::eSuccess ) && statisticCount ) | |
| { | |
| statistics.resize( statisticCount ); | |
| result = static_cast<Result>( d.vkGetPipelineExecutableStatisticsKHR( | |
| m_device, | |
| reinterpret_cast<const VkPipelineExecutableInfoKHR *>( &executableInfo ), | |
| &statisticCount, | |
| reinterpret_cast<VkPipelineExecutableStatisticKHR *>( statistics.data() ) ) ); | |
| VULKAN_HPP_ASSERT( statisticCount <= statistics.size() ); | |
| } | |
| } while ( result == Result::eIncomplete ); | |
| if ( ( result == Result::eSuccess ) && ( statisticCount < statistics.size() ) ) | |
| { | |
| statistics.resize( statisticCount ); | |
| } | |
| return createResultValue( | |
| result, statistics, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineExecutableStatisticsKHR" ); | |
| } | |
| template < | |
| typename PipelineExecutableStatisticKHRAllocator, | |
| typename Dispatch, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, PipelineExecutableStatisticKHR>::value, int>::type> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE | |
| typename ResultValueType<std::vector<PipelineExecutableStatisticKHR, PipelineExecutableStatisticKHRAllocator>>::type | |
| Device::getPipelineExecutableStatisticsKHR( | |
| const PipelineExecutableInfoKHR & executableInfo, | |
| PipelineExecutableStatisticKHRAllocator & pipelineExecutableStatisticKHRAllocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<PipelineExecutableStatisticKHR, PipelineExecutableStatisticKHRAllocator> statistics( | |
| pipelineExecutableStatisticKHRAllocator ); | |
| uint32_t statisticCount; | |
| Result result; | |
| do | |
| { | |
| result = static_cast<Result>( d.vkGetPipelineExecutableStatisticsKHR( | |
| m_device, | |
| reinterpret_cast<const VkPipelineExecutableInfoKHR *>( &executableInfo ), | |
| &statisticCount, | |
| nullptr ) ); | |
| if ( ( result == Result::eSuccess ) && statisticCount ) | |
| { | |
| statistics.resize( statisticCount ); | |
| result = static_cast<Result>( d.vkGetPipelineExecutableStatisticsKHR( | |
| m_device, | |
| reinterpret_cast<const VkPipelineExecutableInfoKHR *>( &executableInfo ), | |
| &statisticCount, | |
| reinterpret_cast<VkPipelineExecutableStatisticKHR *>( statistics.data() ) ) ); | |
| VULKAN_HPP_ASSERT( statisticCount <= statistics.size() ); | |
| } | |
| } while ( result == Result::eIncomplete ); | |
| if ( ( result == Result::eSuccess ) && ( statisticCount < statistics.size() ) ) | |
| { | |
| statistics.resize( statisticCount ); | |
| } | |
| return createResultValue( | |
| result, statistics, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineExecutableStatisticsKHR" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getPipelineExecutableInternalRepresentationsKHR( | |
| const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR * pExecutableInfo, | |
| uint32_t * pInternalRepresentationCount, | |
| VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR * pInternalRepresentations, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkGetPipelineExecutableInternalRepresentationsKHR( | |
| m_device, | |
| reinterpret_cast<const VkPipelineExecutableInfoKHR *>( pExecutableInfo ), | |
| pInternalRepresentationCount, | |
| reinterpret_cast<VkPipelineExecutableInternalRepresentationKHR *>( pInternalRepresentations ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename PipelineExecutableInternalRepresentationKHRAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE | |
| typename ResultValueType<std::vector<PipelineExecutableInternalRepresentationKHR, | |
| PipelineExecutableInternalRepresentationKHRAllocator>>::type | |
| Device::getPipelineExecutableInternalRepresentationsKHR( const PipelineExecutableInfoKHR & executableInfo, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<PipelineExecutableInternalRepresentationKHR, PipelineExecutableInternalRepresentationKHRAllocator> | |
| internalRepresentations; | |
| uint32_t internalRepresentationCount; | |
| Result result; | |
| do | |
| { | |
| result = static_cast<Result>( d.vkGetPipelineExecutableInternalRepresentationsKHR( | |
| m_device, | |
| reinterpret_cast<const VkPipelineExecutableInfoKHR *>( &executableInfo ), | |
| &internalRepresentationCount, | |
| nullptr ) ); | |
| if ( ( result == Result::eSuccess ) && internalRepresentationCount ) | |
| { | |
| internalRepresentations.resize( internalRepresentationCount ); | |
| result = static_cast<Result>( d.vkGetPipelineExecutableInternalRepresentationsKHR( | |
| m_device, | |
| reinterpret_cast<const VkPipelineExecutableInfoKHR *>( &executableInfo ), | |
| &internalRepresentationCount, | |
| reinterpret_cast<VkPipelineExecutableInternalRepresentationKHR *>( internalRepresentations.data() ) ) ); | |
| VULKAN_HPP_ASSERT( internalRepresentationCount <= internalRepresentations.size() ); | |
| } | |
| } while ( result == Result::eIncomplete ); | |
| if ( ( result == Result::eSuccess ) && ( internalRepresentationCount < internalRepresentations.size() ) ) | |
| { | |
| internalRepresentations.resize( internalRepresentationCount ); | |
| } | |
| return createResultValue( result, | |
| internalRepresentations, | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineExecutableInternalRepresentationsKHR" ); | |
| } | |
| template < | |
| typename PipelineExecutableInternalRepresentationKHRAllocator, | |
| typename Dispatch, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, PipelineExecutableInternalRepresentationKHR>::value, | |
| int>::type> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE | |
| typename ResultValueType<std::vector<PipelineExecutableInternalRepresentationKHR, | |
| PipelineExecutableInternalRepresentationKHRAllocator>>::type | |
| Device::getPipelineExecutableInternalRepresentationsKHR( | |
| const PipelineExecutableInfoKHR & executableInfo, | |
| PipelineExecutableInternalRepresentationKHRAllocator & pipelineExecutableInternalRepresentationKHRAllocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<PipelineExecutableInternalRepresentationKHR, PipelineExecutableInternalRepresentationKHRAllocator> | |
| internalRepresentations( pipelineExecutableInternalRepresentationKHRAllocator ); | |
| uint32_t internalRepresentationCount; | |
| Result result; | |
| do | |
| { | |
| result = static_cast<Result>( d.vkGetPipelineExecutableInternalRepresentationsKHR( | |
| m_device, | |
| reinterpret_cast<const VkPipelineExecutableInfoKHR *>( &executableInfo ), | |
| &internalRepresentationCount, | |
| nullptr ) ); | |
| if ( ( result == Result::eSuccess ) && internalRepresentationCount ) | |
| { | |
| internalRepresentations.resize( internalRepresentationCount ); | |
| result = static_cast<Result>( d.vkGetPipelineExecutableInternalRepresentationsKHR( | |
| m_device, | |
| reinterpret_cast<const VkPipelineExecutableInfoKHR *>( &executableInfo ), | |
| &internalRepresentationCount, | |
| reinterpret_cast<VkPipelineExecutableInternalRepresentationKHR *>( internalRepresentations.data() ) ) ); | |
| VULKAN_HPP_ASSERT( internalRepresentationCount <= internalRepresentations.size() ); | |
| } | |
| } while ( result == Result::eIncomplete ); | |
| if ( ( result == Result::eSuccess ) && ( internalRepresentationCount < internalRepresentations.size() ) ) | |
| { | |
| internalRepresentations.resize( internalRepresentationCount ); | |
| } | |
| return createResultValue( result, | |
| internalRepresentations, | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineExecutableInternalRepresentationsKHR" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_NV_device_generated_commands === | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::getGeneratedCommandsMemoryRequirementsNV( | |
| const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV * pInfo, | |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkGetGeneratedCommandsMemoryRequirementsNV( | |
| m_device, | |
| reinterpret_cast<const VkGeneratedCommandsMemoryRequirementsInfoNV *>( pInfo ), | |
| reinterpret_cast<VkMemoryRequirements2 *>( pMemoryRequirements ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2 | |
| Device::getGeneratedCommandsMemoryRequirementsNV( const GeneratedCommandsMemoryRequirementsInfoNV & info, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements; | |
| d.vkGetGeneratedCommandsMemoryRequirementsNV( | |
| m_device, | |
| reinterpret_cast<const VkGeneratedCommandsMemoryRequirementsInfoNV *>( &info ), | |
| reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) ); | |
| return memoryRequirements; | |
| } | |
| template <typename X, typename Y, typename... Z, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> | |
| Device::getGeneratedCommandsMemoryRequirementsNV( const GeneratedCommandsMemoryRequirementsInfoNV & 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.vkGetGeneratedCommandsMemoryRequirementsNV( | |
| m_device, | |
| reinterpret_cast<const VkGeneratedCommandsMemoryRequirementsInfoNV *>( &info ), | |
| reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) ); | |
| return structureChain; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::preprocessGeneratedCommandsNV( | |
| const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV * pGeneratedCommandsInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdPreprocessGeneratedCommandsNV( | |
| m_commandBuffer, reinterpret_cast<const VkGeneratedCommandsInfoNV *>( pGeneratedCommandsInfo ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::preprocessGeneratedCommandsNV( const GeneratedCommandsInfoNV & generatedCommandsInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdPreprocessGeneratedCommandsNV( | |
| m_commandBuffer, reinterpret_cast<const VkGeneratedCommandsInfoNV *>( &generatedCommandsInfo ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::executeGeneratedCommandsNV( | |
| VULKAN_HPP_NAMESPACE::Bool32 isPreprocessed, | |
| const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV * pGeneratedCommandsInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdExecuteGeneratedCommandsNV( m_commandBuffer, | |
| static_cast<VkBool32>( isPreprocessed ), | |
| reinterpret_cast<const VkGeneratedCommandsInfoNV *>( pGeneratedCommandsInfo ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::executeGeneratedCommandsNV( VULKAN_HPP_NAMESPACE::Bool32 isPreprocessed, | |
| const GeneratedCommandsInfoNV & generatedCommandsInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdExecuteGeneratedCommandsNV( m_commandBuffer, | |
| static_cast<VkBool32>( isPreprocessed ), | |
| reinterpret_cast<const VkGeneratedCommandsInfoNV *>( &generatedCommandsInfo ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::bindPipelineShaderGroupNV( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, | |
| VULKAN_HPP_NAMESPACE::Pipeline pipeline, | |
| uint32_t groupIndex, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdBindPipelineShaderGroupNV( m_commandBuffer, | |
| static_cast<VkPipelineBindPoint>( pipelineBindPoint ), | |
| static_cast<VkPipeline>( pipeline ), | |
| groupIndex ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createIndirectCommandsLayoutNV( | |
| const VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV * pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV * pIndirectCommandsLayout, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkCreateIndirectCommandsLayoutNV( m_device, | |
| reinterpret_cast<const VkIndirectCommandsLayoutCreateInfoNV *>( pCreateInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), | |
| reinterpret_cast<VkIndirectCommandsLayoutNV *>( pIndirectCommandsLayout ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV>::type | |
| Device::createIndirectCommandsLayoutNV( const IndirectCommandsLayoutCreateInfoNV & createInfo, | |
| Optional<const AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout; | |
| Result result = static_cast<Result>( d.vkCreateIndirectCommandsLayoutNV( | |
| m_device, | |
| reinterpret_cast<const VkIndirectCommandsLayoutCreateInfoNV *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkIndirectCommandsLayoutNV *>( &indirectCommandsLayout ) ) ); | |
| return createResultValue( | |
| result, indirectCommandsLayout, VULKAN_HPP_NAMESPACE_STRING "::Device::createIndirectCommandsLayoutNV" ); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV, Dispatch>>::type | |
| Device::createIndirectCommandsLayoutNVUnique( const IndirectCommandsLayoutCreateInfoNV & createInfo, | |
| Optional<const AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout; | |
| Result result = static_cast<Result>( d.vkCreateIndirectCommandsLayoutNV( | |
| m_device, | |
| reinterpret_cast<const VkIndirectCommandsLayoutCreateInfoNV *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkIndirectCommandsLayoutNV *>( &indirectCommandsLayout ) ) ); | |
| ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d ); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV, Dispatch>( | |
| result, | |
| indirectCommandsLayout, | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createIndirectCommandsLayoutNVUnique", | |
| deleter ); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| Device::destroyIndirectCommandsLayoutNV( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyIndirectCommandsLayoutNV( m_device, | |
| static_cast<VkIndirectCommandsLayoutNV>( indirectCommandsLayout ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| Device::destroyIndirectCommandsLayoutNV( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout, | |
| Optional<const AllocationCallbacks> allocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyIndirectCommandsLayoutNV( | |
| m_device, | |
| static_cast<VkIndirectCommandsLayoutNV>( indirectCommandsLayout ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyIndirectCommandsLayoutNV( m_device, | |
| static_cast<VkIndirectCommandsLayoutNV>( indirectCommandsLayout ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout, | |
| Optional<const AllocationCallbacks> allocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyIndirectCommandsLayoutNV( | |
| m_device, | |
| static_cast<VkIndirectCommandsLayoutNV>( indirectCommandsLayout ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_EXT_acquire_drm_display === | |
| #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::acquireDrmDisplayEXT( | |
| int32_t drmFd, VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkAcquireDrmDisplayEXT( m_physicalDevice, drmFd, static_cast<VkDisplayKHR>( display ) ) ); | |
| } | |
| #else | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE typename ResultValueType<void>::type PhysicalDevice::acquireDrmDisplayEXT( | |
| int32_t drmFd, VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| Result result = | |
| static_cast<Result>( d.vkAcquireDrmDisplayEXT( m_physicalDevice, drmFd, static_cast<VkDisplayKHR>( display ) ) ); | |
| return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::acquireDrmDisplayEXT" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| PhysicalDevice::getDrmDisplayEXT( int32_t drmFd, | |
| uint32_t connectorId, | |
| VULKAN_HPP_NAMESPACE::DisplayKHR * display, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkGetDrmDisplayEXT( m_physicalDevice, drmFd, connectorId, reinterpret_cast<VkDisplayKHR *>( display ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayKHR>::type | |
| PhysicalDevice::getDrmDisplayEXT( int32_t drmFd, uint32_t connectorId, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::DisplayKHR display; | |
| Result result = static_cast<Result>( | |
| d.vkGetDrmDisplayEXT( m_physicalDevice, drmFd, connectorId, reinterpret_cast<VkDisplayKHR *>( &display ) ) ); | |
| return createResultValue( result, display, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDrmDisplayEXT" ); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>>::type | |
| PhysicalDevice::getDrmDisplayEXTUnique( int32_t drmFd, uint32_t connectorId, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::DisplayKHR display; | |
| Result result = static_cast<Result>( | |
| d.vkGetDrmDisplayEXT( m_physicalDevice, drmFd, connectorId, reinterpret_cast<VkDisplayKHR *>( &display ) ) ); | |
| ObjectRelease<PhysicalDevice, Dispatch> deleter( *this, d ); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>( | |
| result, display, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDrmDisplayEXTUnique", deleter ); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_EXT_private_data === | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::createPrivateDataSlotEXT( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfoEXT * pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT * pPrivateDataSlot, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkCreatePrivateDataSlotEXT( m_device, | |
| reinterpret_cast<const VkPrivateDataSlotCreateInfoEXT *>( pCreateInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), | |
| reinterpret_cast<VkPrivateDataSlotEXT *>( pPrivateDataSlot ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT>::type | |
| Device::createPrivateDataSlotEXT( const PrivateDataSlotCreateInfoEXT & createInfo, | |
| Optional<const AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot; | |
| Result result = static_cast<Result>( | |
| d.vkCreatePrivateDataSlotEXT( m_device, | |
| reinterpret_cast<const VkPrivateDataSlotCreateInfoEXT *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkPrivateDataSlotEXT *>( &privateDataSlot ) ) ); | |
| return createResultValue( | |
| result, privateDataSlot, VULKAN_HPP_NAMESPACE_STRING "::Device::createPrivateDataSlotEXT" ); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT, Dispatch>>::type | |
| Device::createPrivateDataSlotEXTUnique( const PrivateDataSlotCreateInfoEXT & createInfo, | |
| Optional<const AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot; | |
| Result result = static_cast<Result>( | |
| d.vkCreatePrivateDataSlotEXT( m_device, | |
| reinterpret_cast<const VkPrivateDataSlotCreateInfoEXT *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkPrivateDataSlotEXT *>( &privateDataSlot ) ) ); | |
| ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d ); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT, Dispatch>( | |
| result, privateDataSlot, VULKAN_HPP_NAMESPACE_STRING "::Device::createPrivateDataSlotEXTUnique", deleter ); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| Device::destroyPrivateDataSlotEXT( VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyPrivateDataSlotEXT( m_device, | |
| static_cast<VkPrivateDataSlotEXT>( privateDataSlot ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroyPrivateDataSlotEXT( VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot, | |
| Optional<const AllocationCallbacks> allocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyPrivateDataSlotEXT( m_device, | |
| static_cast<VkPrivateDataSlotEXT>( privateDataSlot ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyPrivateDataSlotEXT( m_device, | |
| static_cast<VkPrivateDataSlotEXT>( privateDataSlot ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot, | |
| Optional<const AllocationCallbacks> allocator, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkDestroyPrivateDataSlotEXT( m_device, | |
| static_cast<VkPrivateDataSlotEXT>( privateDataSlot ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::setPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType objectType, | |
| uint64_t objectHandle, | |
| VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot, | |
| uint64_t data, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkSetPrivateDataEXT( m_device, | |
| static_cast<VkObjectType>( objectType ), | |
| objectHandle, | |
| static_cast<VkPrivateDataSlotEXT>( privateDataSlot ), | |
| data ) ); | |
| } | |
| #else | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| Device::setPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType objectType, | |
| uint64_t objectHandle, | |
| VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot, | |
| uint64_t data, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| Result result = static_cast<Result>( d.vkSetPrivateDataEXT( m_device, | |
| static_cast<VkObjectType>( objectType ), | |
| objectHandle, | |
| static_cast<VkPrivateDataSlotEXT>( privateDataSlot ), | |
| data ) ); | |
| return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setPrivateDataEXT" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::getPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType objectType, | |
| uint64_t objectHandle, | |
| VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot, | |
| uint64_t * pData, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkGetPrivateDataEXT( m_device, | |
| static_cast<VkObjectType>( objectType ), | |
| objectHandle, | |
| static_cast<VkPrivateDataSlotEXT>( privateDataSlot ), | |
| pData ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t | |
| Device::getPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType objectType, | |
| uint64_t objectHandle, | |
| VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| uint64_t data; | |
| d.vkGetPrivateDataEXT( m_device, | |
| static_cast<VkObjectType>( objectType ), | |
| objectHandle, | |
| static_cast<VkPrivateDataSlotEXT>( privateDataSlot ), | |
| &data ); | |
| return data; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #if defined( VK_ENABLE_BETA_EXTENSIONS ) | |
| //=== VK_KHR_video_encode_queue === | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::encodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR * pEncodeInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdEncodeVideoKHR( m_commandBuffer, reinterpret_cast<const VkVideoEncodeInfoKHR *>( pEncodeInfo ) ); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::encodeVideoKHR( const VideoEncodeInfoKHR & encodeInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdEncodeVideoKHR( m_commandBuffer, reinterpret_cast<const VkVideoEncodeInfoKHR *>( &encodeInfo ) ); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #endif /*VK_ENABLE_BETA_EXTENSIONS*/ | |
| //=== VK_KHR_synchronization2 === | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setEvent2KHR( VULKAN_HPP_NAMESPACE::Event event, | |
| const VULKAN_HPP_NAMESPACE::DependencyInfoKHR * pDependencyInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdSetEvent2KHR( m_commandBuffer, | |
| static_cast<VkEvent>( event ), | |
| reinterpret_cast<const VkDependencyInfoKHR *>( pDependencyInfo ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setEvent2KHR( VULKAN_HPP_NAMESPACE::Event event, | |
| const DependencyInfoKHR & dependencyInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdSetEvent2KHR( m_commandBuffer, | |
| static_cast<VkEvent>( event ), | |
| reinterpret_cast<const VkDependencyInfoKHR *>( &dependencyInfo ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::resetEvent2KHR( VULKAN_HPP_NAMESPACE::Event event, | |
| VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR stageMask, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdResetEvent2KHR( | |
| m_commandBuffer, static_cast<VkEvent>( event ), static_cast<VkPipelineStageFlags2KHR>( stageMask ) ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::waitEvents2KHR( uint32_t eventCount, | |
| const VULKAN_HPP_NAMESPACE::Event * pEvents, | |
| const VULKAN_HPP_NAMESPACE::DependencyInfoKHR * pDependencyInfos, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdWaitEvents2KHR( m_commandBuffer, | |
| eventCount, | |
| reinterpret_cast<const VkEvent *>( pEvents ), | |
| reinterpret_cast<const VkDependencyInfoKHR *>( pDependencyInfos ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::waitEvents2KHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const & events, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::DependencyInfoKHR> const & dependencyInfos, | |
| 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( events.size() == dependencyInfos.size() ); | |
| # else | |
| if ( events.size() != dependencyInfos.size() ) | |
| { | |
| throw LogicError( VULKAN_HPP_NAMESPACE_STRING | |
| "::CommandBuffer::waitEvents2KHR: events.size() != dependencyInfos.size()" ); | |
| } | |
| # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ | |
| d.vkCmdWaitEvents2KHR( m_commandBuffer, | |
| events.size(), | |
| reinterpret_cast<const VkEvent *>( events.data() ), | |
| reinterpret_cast<const VkDependencyInfoKHR *>( dependencyInfos.data() ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::pipelineBarrier2KHR( const VULKAN_HPP_NAMESPACE::DependencyInfoKHR * pDependencyInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdPipelineBarrier2KHR( m_commandBuffer, reinterpret_cast<const VkDependencyInfoKHR *>( pDependencyInfo ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier2KHR( const DependencyInfoKHR & dependencyInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdPipelineBarrier2KHR( m_commandBuffer, reinterpret_cast<const VkDependencyInfoKHR *>( &dependencyInfo ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::writeTimestamp2KHR( VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR stage, | |
| VULKAN_HPP_NAMESPACE::QueryPool queryPool, | |
| uint32_t query, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdWriteTimestamp2KHR( | |
| m_commandBuffer, static_cast<VkPipelineStageFlags2KHR>( stage ), static_cast<VkQueryPool>( queryPool ), query ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Queue::submit2KHR( uint32_t submitCount, | |
| const VULKAN_HPP_NAMESPACE::SubmitInfo2KHR * pSubmits, | |
| VULKAN_HPP_NAMESPACE::Fence fence, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkQueueSubmit2KHR( | |
| m_queue, submitCount, reinterpret_cast<const VkSubmitInfo2KHR *>( pSubmits ), static_cast<VkFence>( fence ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| Queue::submit2KHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo2KHR> 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.vkQueueSubmit2KHR( m_queue, | |
| submits.size(), | |
| reinterpret_cast<const VkSubmitInfo2KHR *>( submits.data() ), | |
| static_cast<VkFence>( fence ) ) ); | |
| return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::submit2KHR" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::writeBufferMarker2AMD( VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR stage, | |
| VULKAN_HPP_NAMESPACE::Buffer dstBuffer, | |
| VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, | |
| uint32_t marker, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdWriteBufferMarker2AMD( m_commandBuffer, | |
| static_cast<VkPipelineStageFlags2KHR>( stage ), | |
| static_cast<VkBuffer>( dstBuffer ), | |
| static_cast<VkDeviceSize>( dstOffset ), | |
| marker ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void Queue::getCheckpointData2NV( uint32_t * pCheckpointDataCount, | |
| VULKAN_HPP_NAMESPACE::CheckpointData2NV * pCheckpointData, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkGetQueueCheckpointData2NV( | |
| m_queue, pCheckpointDataCount, reinterpret_cast<VkCheckpointData2NV *>( pCheckpointData ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename CheckpointData2NVAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<CheckpointData2NV, CheckpointData2NVAllocator> | |
| Queue::getCheckpointData2NV( Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<CheckpointData2NV, CheckpointData2NVAllocator> checkpointData; | |
| uint32_t checkpointDataCount; | |
| d.vkGetQueueCheckpointData2NV( m_queue, &checkpointDataCount, nullptr ); | |
| checkpointData.resize( checkpointDataCount ); | |
| d.vkGetQueueCheckpointData2NV( | |
| m_queue, &checkpointDataCount, reinterpret_cast<VkCheckpointData2NV *>( checkpointData.data() ) ); | |
| VULKAN_HPP_ASSERT( checkpointDataCount <= checkpointData.size() ); | |
| return checkpointData; | |
| } | |
| template <typename CheckpointData2NVAllocator, | |
| typename Dispatch, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, CheckpointData2NV>::value, int>::type> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<CheckpointData2NV, CheckpointData2NVAllocator> | |
| Queue::getCheckpointData2NV( CheckpointData2NVAllocator & checkpointData2NVAllocator, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<CheckpointData2NV, CheckpointData2NVAllocator> checkpointData( checkpointData2NVAllocator ); | |
| uint32_t checkpointDataCount; | |
| d.vkGetQueueCheckpointData2NV( m_queue, &checkpointDataCount, nullptr ); | |
| checkpointData.resize( checkpointDataCount ); | |
| d.vkGetQueueCheckpointData2NV( | |
| m_queue, &checkpointDataCount, reinterpret_cast<VkCheckpointData2NV *>( checkpointData.data() ) ); | |
| VULKAN_HPP_ASSERT( checkpointDataCount <= checkpointData.size() ); | |
| return checkpointData; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_NV_fragment_shading_rate_enums === | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setFragmentShadingRateEnumNV( | |
| VULKAN_HPP_NAMESPACE::FragmentShadingRateNV shadingRate, | |
| const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2], | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdSetFragmentShadingRateEnumNV( m_commandBuffer, | |
| static_cast<VkFragmentShadingRateNV>( shadingRate ), | |
| reinterpret_cast<const VkFragmentShadingRateCombinerOpKHR *>( combinerOps ) ); | |
| } | |
| //=== VK_KHR_copy_commands2 === | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::copyBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2KHR * pCopyBufferInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdCopyBuffer2KHR( m_commandBuffer, reinterpret_cast<const VkCopyBufferInfo2KHR *>( pCopyBufferInfo ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::copyBuffer2KHR( const CopyBufferInfo2KHR & copyBufferInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdCopyBuffer2KHR( m_commandBuffer, reinterpret_cast<const VkCopyBufferInfo2KHR *>( ©BufferInfo ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::copyImage2KHR( const VULKAN_HPP_NAMESPACE::CopyImageInfo2KHR * pCopyImageInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdCopyImage2KHR( m_commandBuffer, reinterpret_cast<const VkCopyImageInfo2KHR *>( pCopyImageInfo ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::copyImage2KHR( const CopyImageInfo2KHR & copyImageInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdCopyImage2KHR( m_commandBuffer, reinterpret_cast<const VkCopyImageInfo2KHR *>( ©ImageInfo ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage2KHR( | |
| const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2KHR * pCopyBufferToImageInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdCopyBufferToImage2KHR( m_commandBuffer, | |
| reinterpret_cast<const VkCopyBufferToImageInfo2KHR *>( pCopyBufferToImageInfo ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage2KHR( const CopyBufferToImageInfo2KHR & copyBufferToImageInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdCopyBufferToImage2KHR( m_commandBuffer, | |
| reinterpret_cast<const VkCopyBufferToImageInfo2KHR *>( ©BufferToImageInfo ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer2KHR( | |
| const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2KHR * pCopyImageToBufferInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdCopyImageToBuffer2KHR( m_commandBuffer, | |
| reinterpret_cast<const VkCopyImageToBufferInfo2KHR *>( pCopyImageToBufferInfo ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer2KHR( const CopyImageToBufferInfo2KHR & copyImageToBufferInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdCopyImageToBuffer2KHR( m_commandBuffer, | |
| reinterpret_cast<const VkCopyImageToBufferInfo2KHR *>( ©ImageToBufferInfo ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::blitImage2KHR( const VULKAN_HPP_NAMESPACE::BlitImageInfo2KHR * pBlitImageInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdBlitImage2KHR( m_commandBuffer, reinterpret_cast<const VkBlitImageInfo2KHR *>( pBlitImageInfo ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::blitImage2KHR( const BlitImageInfo2KHR & blitImageInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdBlitImage2KHR( m_commandBuffer, reinterpret_cast<const VkBlitImageInfo2KHR *>( &blitImageInfo ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::resolveImage2KHR( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2KHR * pResolveImageInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdResolveImage2KHR( m_commandBuffer, reinterpret_cast<const VkResolveImageInfo2KHR *>( pResolveImageInfo ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::resolveImage2KHR( const ResolveImageInfo2KHR & resolveImageInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdResolveImage2KHR( m_commandBuffer, reinterpret_cast<const VkResolveImageInfo2KHR *>( &resolveImageInfo ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #if defined( VK_USE_PLATFORM_WIN32_KHR ) | |
| //=== VK_NV_acquire_winrt_display === | |
| # ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::acquireWinrtDisplayNV( | |
| VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkAcquireWinrtDisplayNV( m_physicalDevice, static_cast<VkDisplayKHR>( display ) ) ); | |
| } | |
| # else | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| PhysicalDevice::acquireWinrtDisplayNV( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| Result result = | |
| static_cast<Result>( d.vkAcquireWinrtDisplayNV( m_physicalDevice, static_cast<VkDisplayKHR>( display ) ) ); | |
| return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::acquireWinrtDisplayNV" ); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| PhysicalDevice::getWinrtDisplayNV( uint32_t deviceRelativeId, | |
| VULKAN_HPP_NAMESPACE::DisplayKHR * pDisplay, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkGetWinrtDisplayNV( m_physicalDevice, deviceRelativeId, reinterpret_cast<VkDisplayKHR *>( pDisplay ) ) ); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayKHR>::type | |
| PhysicalDevice::getWinrtDisplayNV( uint32_t deviceRelativeId, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::DisplayKHR display; | |
| Result result = static_cast<Result>( | |
| d.vkGetWinrtDisplayNV( m_physicalDevice, deviceRelativeId, reinterpret_cast<VkDisplayKHR *>( &display ) ) ); | |
| return createResultValue( result, display, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getWinrtDisplayNV" ); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>>::type | |
| PhysicalDevice::getWinrtDisplayNVUnique( uint32_t deviceRelativeId, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::DisplayKHR display; | |
| Result result = static_cast<Result>( | |
| d.vkGetWinrtDisplayNV( m_physicalDevice, deviceRelativeId, reinterpret_cast<VkDisplayKHR *>( &display ) ) ); | |
| ObjectRelease<PhysicalDevice, Dispatch> deleter( *this, d ); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>( | |
| result, display, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getWinrtDisplayNVUnique", deleter ); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #endif /*VK_USE_PLATFORM_WIN32_KHR*/ | |
| #if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) | |
| //=== VK_EXT_directfb_surface === | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Instance::createDirectFBSurfaceEXT( const VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT * pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkCreateDirectFBSurfaceEXT( m_instance, | |
| reinterpret_cast<const VkDirectFBSurfaceCreateInfoEXT *>( pCreateInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), | |
| reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) ); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type | |
| Instance::createDirectFBSurfaceEXT( const DirectFBSurfaceCreateInfoEXT & createInfo, | |
| Optional<const 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.vkCreateDirectFBSurfaceEXT( m_instance, | |
| reinterpret_cast<const VkDirectFBSurfaceCreateInfoEXT *>( &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::createDirectFBSurfaceEXT" ); | |
| } | |
| # 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::createDirectFBSurfaceEXTUnique( const DirectFBSurfaceCreateInfoEXT & createInfo, | |
| Optional<const 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.vkCreateDirectFBSurfaceEXT( m_instance, | |
| reinterpret_cast<const VkDirectFBSurfaceCreateInfoEXT *>( &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::createDirectFBSurfaceEXTUnique", deleter ); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE Bool32 PhysicalDevice::getDirectFBPresentationSupportEXT( | |
| uint32_t queueFamilyIndex, IDirectFB * dfb, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Bool32>( | |
| d.vkGetPhysicalDeviceDirectFBPresentationSupportEXT( m_physicalDevice, queueFamilyIndex, dfb ) ); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE Bool32 PhysicalDevice::getDirectFBPresentationSupportEXT( | |
| uint32_t queueFamilyIndex, IDirectFB & dfb, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return d.vkGetPhysicalDeviceDirectFBPresentationSupportEXT( m_physicalDevice, queueFamilyIndex, &dfb ); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ | |
| //=== VK_KHR_ray_tracing_pipeline === | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::traceRaysKHR( | |
| const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pRaygenShaderBindingTable, | |
| const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pMissShaderBindingTable, | |
| const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pHitShaderBindingTable, | |
| const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pCallableShaderBindingTable, | |
| uint32_t width, | |
| uint32_t height, | |
| uint32_t depth, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdTraceRaysKHR( m_commandBuffer, | |
| reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( pRaygenShaderBindingTable ), | |
| reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( pMissShaderBindingTable ), | |
| reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( pHitShaderBindingTable ), | |
| reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( pCallableShaderBindingTable ), | |
| width, | |
| height, | |
| depth ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::traceRaysKHR( const StridedDeviceAddressRegionKHR & raygenShaderBindingTable, | |
| const StridedDeviceAddressRegionKHR & missShaderBindingTable, | |
| const StridedDeviceAddressRegionKHR & hitShaderBindingTable, | |
| const StridedDeviceAddressRegionKHR & callableShaderBindingTable, | |
| uint32_t width, | |
| uint32_t height, | |
| uint32_t depth, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdTraceRaysKHR( m_commandBuffer, | |
| reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &raygenShaderBindingTable ), | |
| reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &missShaderBindingTable ), | |
| reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &hitShaderBindingTable ), | |
| reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &callableShaderBindingTable ), | |
| width, | |
| height, | |
| depth ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::createRayTracingPipelinesKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, | |
| VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| uint32_t createInfoCount, | |
| const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR * pCreateInfos, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| VULKAN_HPP_NAMESPACE::Pipeline * pPipelines, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkCreateRayTracingPipelinesKHR( m_device, | |
| static_cast<VkDeferredOperationKHR>( deferredOperation ), | |
| static_cast<VkPipelineCache>( pipelineCache ), | |
| createInfoCount, | |
| reinterpret_cast<const VkRayTracingPipelineCreateInfoKHR *>( pCreateInfos ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), | |
| reinterpret_cast<VkPipeline *>( pPipelines ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename PipelineAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<Pipeline, PipelineAllocator>> | |
| Device::createRayTracingPipelinesKHR( | |
| VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, | |
| VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos, | |
| Optional<const AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<Pipeline, PipelineAllocator> pipelines( createInfos.size() ); | |
| Result result = static_cast<Result>( d.vkCreateRayTracingPipelinesKHR( | |
| m_device, | |
| static_cast<VkDeferredOperationKHR>( deferredOperation ), | |
| static_cast<VkPipelineCache>( pipelineCache ), | |
| createInfos.size(), | |
| reinterpret_cast<const VkRayTracingPipelineCreateInfoKHR *>( createInfos.data() ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkPipeline *>( pipelines.data() ) ) ); | |
| return createResultValue( result, | |
| pipelines, | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesKHR", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, | |
| VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR, | |
| VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR, | |
| VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); | |
| } | |
| 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<Pipeline, PipelineAllocator>> | |
| Device::createRayTracingPipelinesKHR( | |
| VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, | |
| VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos, | |
| Optional<const AllocationCallbacks> allocator, | |
| PipelineAllocator & pipelineAllocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| std::vector<Pipeline, PipelineAllocator> pipelines( createInfos.size(), pipelineAllocator ); | |
| Result result = static_cast<Result>( d.vkCreateRayTracingPipelinesKHR( | |
| m_device, | |
| static_cast<VkDeferredOperationKHR>( deferredOperation ), | |
| static_cast<VkPipelineCache>( pipelineCache ), | |
| createInfos.size(), | |
| reinterpret_cast<const VkRayTracingPipelineCreateInfoKHR *>( createInfos.data() ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkPipeline *>( pipelines.data() ) ) ); | |
| return createResultValue( result, | |
| pipelines, | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesKHR", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, | |
| VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR, | |
| VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR, | |
| VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<Pipeline> | |
| Device::createRayTracingPipelineKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, | |
| VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR & createInfo, | |
| Optional<const AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| Pipeline pipeline; | |
| Result result = static_cast<Result>( | |
| d.vkCreateRayTracingPipelinesKHR( m_device, | |
| static_cast<VkDeferredOperationKHR>( deferredOperation ), | |
| static_cast<VkPipelineCache>( pipelineCache ), | |
| 1, | |
| reinterpret_cast<const VkRayTracingPipelineCreateInfoKHR *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkPipeline *>( &pipeline ) ) ); | |
| return createResultValue( result, | |
| pipeline, | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelineKHR", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, | |
| VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR, | |
| VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR, | |
| VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); | |
| } | |
| # 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::createRayTracingPipelinesKHRUnique( | |
| VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, | |
| VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos, | |
| Optional<const 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.vkCreateRayTracingPipelinesKHR( | |
| m_device, | |
| static_cast<VkDeferredOperationKHR>( deferredOperation ), | |
| static_cast<VkPipelineCache>( pipelineCache ), | |
| createInfos.size(), | |
| reinterpret_cast<const VkRayTracingPipelineCreateInfoKHR *>( createInfos.data() ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkPipeline *>( pipelines.data() ) ) ); | |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) || | |
| ( result == VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR ) || | |
| ( result == VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR ) || | |
| ( 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::createRayTracingPipelinesKHRUnique", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, | |
| VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR, | |
| VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR, | |
| 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::createRayTracingPipelinesKHRUnique( | |
| VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, | |
| VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos, | |
| Optional<const 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.vkCreateRayTracingPipelinesKHR( | |
| m_device, | |
| static_cast<VkDeferredOperationKHR>( deferredOperation ), | |
| static_cast<VkPipelineCache>( pipelineCache ), | |
| createInfos.size(), | |
| reinterpret_cast<const VkRayTracingPipelineCreateInfoKHR *>( createInfos.data() ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkPipeline *>( pipelines.data() ) ) ); | |
| if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) || | |
| ( result == VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR ) || | |
| ( result == VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR ) || | |
| ( 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::createRayTracingPipelinesKHRUnique", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, | |
| VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR, | |
| VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR, | |
| VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<UniqueHandle<Pipeline, Dispatch>> | |
| Device::createRayTracingPipelineKHRUnique( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, | |
| VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR & createInfo, | |
| Optional<const AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| Pipeline pipeline; | |
| Result result = static_cast<Result>( | |
| d.vkCreateRayTracingPipelinesKHR( m_device, | |
| static_cast<VkDeferredOperationKHR>( deferredOperation ), | |
| static_cast<VkPipelineCache>( pipelineCache ), | |
| 1, | |
| reinterpret_cast<const VkRayTracingPipelineCreateInfoKHR *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkPipeline *>( &pipeline ) ) ); | |
| ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d ); | |
| return createResultValue<Pipeline, Dispatch>( result, | |
| pipeline, | |
| VULKAN_HPP_NAMESPACE_STRING | |
| "::Device::createRayTracingPipelineKHRUnique", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, | |
| VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR, | |
| VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR, | |
| VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT }, | |
| deleter ); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::getRayTracingShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline, | |
| uint32_t firstGroup, | |
| uint32_t groupCount, | |
| size_t dataSize, | |
| void * pData, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesKHR( | |
| m_device, static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, dataSize, pData ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename T, typename Dispatch> | |
| VULKAN_HPP_DEPRECATED( "This function is deprecated. Use one of the other flavours of it." ) | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<void>::type Device::getRayTracingShaderGroupHandlesKHR( | |
| VULKAN_HPP_NAMESPACE::Pipeline pipeline, | |
| uint32_t firstGroup, | |
| uint32_t groupCount, | |
| ArrayProxy<T> const & data, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| Result result = | |
| static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesKHR( m_device, | |
| static_cast<VkPipeline>( pipeline ), | |
| firstGroup, | |
| groupCount, | |
| data.size() * sizeof( T ), | |
| reinterpret_cast<void *>( data.data() ) ) ); | |
| return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandlesKHR" ); | |
| } | |
| template <typename T, typename Allocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<std::vector<T, Allocator>>::type | |
| Device::getRayTracingShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline, | |
| uint32_t firstGroup, | |
| uint32_t groupCount, | |
| size_t dataSize, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_ASSERT( dataSize % sizeof( T ) == 0 ); | |
| std::vector<T, Allocator> data( dataSize / sizeof( T ) ); | |
| Result result = | |
| static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesKHR( m_device, | |
| static_cast<VkPipeline>( pipeline ), | |
| firstGroup, | |
| groupCount, | |
| data.size() * sizeof( T ), | |
| reinterpret_cast<void *>( data.data() ) ) ); | |
| return createResultValue( | |
| result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandlesKHR" ); | |
| } | |
| template <typename T, typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<T>::type | |
| Device::getRayTracingShaderGroupHandleKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline, | |
| uint32_t firstGroup, | |
| uint32_t groupCount, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| T data; | |
| Result result = static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesKHR( m_device, | |
| static_cast<VkPipeline>( pipeline ), | |
| firstGroup, | |
| groupCount, | |
| sizeof( T ), | |
| reinterpret_cast<void *>( &data ) ) ); | |
| return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandleKHR" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::getRayTracingCaptureReplayShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline, | |
| uint32_t firstGroup, | |
| uint32_t groupCount, | |
| size_t dataSize, | |
| void * pData, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( | |
| m_device, static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, dataSize, pData ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename T, typename Dispatch> | |
| VULKAN_HPP_DEPRECATED( "This function is deprecated. Use one of the other flavours of it." ) | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<void>::type Device::getRayTracingCaptureReplayShaderGroupHandlesKHR( | |
| VULKAN_HPP_NAMESPACE::Pipeline pipeline, | |
| uint32_t firstGroup, | |
| uint32_t groupCount, | |
| ArrayProxy<T> const & data, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| Result result = static_cast<Result>( | |
| d.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( m_device, | |
| static_cast<VkPipeline>( pipeline ), | |
| firstGroup, | |
| groupCount, | |
| data.size() * sizeof( T ), | |
| reinterpret_cast<void *>( data.data() ) ) ); | |
| return createResultValue( result, | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingCaptureReplayShaderGroupHandlesKHR" ); | |
| } | |
| template <typename T, typename Allocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<std::vector<T, Allocator>>::type | |
| Device::getRayTracingCaptureReplayShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline, | |
| uint32_t firstGroup, | |
| uint32_t groupCount, | |
| size_t dataSize, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_ASSERT( dataSize % sizeof( T ) == 0 ); | |
| std::vector<T, Allocator> data( dataSize / sizeof( T ) ); | |
| Result result = static_cast<Result>( | |
| d.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( m_device, | |
| static_cast<VkPipeline>( pipeline ), | |
| firstGroup, | |
| groupCount, | |
| data.size() * sizeof( T ), | |
| reinterpret_cast<void *>( data.data() ) ) ); | |
| return createResultValue( | |
| result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingCaptureReplayShaderGroupHandlesKHR" ); | |
| } | |
| template <typename T, typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<T>::type | |
| Device::getRayTracingCaptureReplayShaderGroupHandleKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline, | |
| uint32_t firstGroup, | |
| uint32_t groupCount, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| T data; | |
| Result result = | |
| static_cast<Result>( d.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( m_device, | |
| static_cast<VkPipeline>( pipeline ), | |
| firstGroup, | |
| groupCount, | |
| sizeof( T ), | |
| reinterpret_cast<void *>( &data ) ) ); | |
| return createResultValue( | |
| result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingCaptureReplayShaderGroupHandleKHR" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::traceRaysIndirectKHR( | |
| const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pRaygenShaderBindingTable, | |
| const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pMissShaderBindingTable, | |
| const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pHitShaderBindingTable, | |
| const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pCallableShaderBindingTable, | |
| VULKAN_HPP_NAMESPACE::DeviceAddress indirectDeviceAddress, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdTraceRaysIndirectKHR( | |
| m_commandBuffer, | |
| reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( pRaygenShaderBindingTable ), | |
| reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( pMissShaderBindingTable ), | |
| reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( pHitShaderBindingTable ), | |
| reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( pCallableShaderBindingTable ), | |
| static_cast<VkDeviceAddress>( indirectDeviceAddress ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::traceRaysIndirectKHR( const StridedDeviceAddressRegionKHR & raygenShaderBindingTable, | |
| const StridedDeviceAddressRegionKHR & missShaderBindingTable, | |
| const StridedDeviceAddressRegionKHR & hitShaderBindingTable, | |
| const StridedDeviceAddressRegionKHR & callableShaderBindingTable, | |
| VULKAN_HPP_NAMESPACE::DeviceAddress indirectDeviceAddress, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdTraceRaysIndirectKHR( | |
| m_commandBuffer, | |
| reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &raygenShaderBindingTable ), | |
| reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &missShaderBindingTable ), | |
| reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &hitShaderBindingTable ), | |
| reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &callableShaderBindingTable ), | |
| static_cast<VkDeviceAddress>( indirectDeviceAddress ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE DeviceSize | |
| Device::getRayTracingShaderGroupStackSizeKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline, | |
| uint32_t group, | |
| VULKAN_HPP_NAMESPACE::ShaderGroupShaderKHR groupShader, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<DeviceSize>( d.vkGetRayTracingShaderGroupStackSizeKHR( | |
| m_device, static_cast<VkPipeline>( pipeline ), group, static_cast<VkShaderGroupShaderKHR>( groupShader ) ) ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::setRayTracingPipelineStackSizeKHR( uint32_t pipelineStackSize, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdSetRayTracingPipelineStackSizeKHR( m_commandBuffer, pipelineStackSize ); | |
| } | |
| //=== VK_EXT_vertex_input_dynamic_state === | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setVertexInputEXT( | |
| uint32_t vertexBindingDescriptionCount, | |
| const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT * pVertexBindingDescriptions, | |
| uint32_t vertexAttributeDescriptionCount, | |
| const VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT * pVertexAttributeDescriptions, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdSetVertexInputEXT( | |
| m_commandBuffer, | |
| vertexBindingDescriptionCount, | |
| reinterpret_cast<const VkVertexInputBindingDescription2EXT *>( pVertexBindingDescriptions ), | |
| vertexAttributeDescriptionCount, | |
| reinterpret_cast<const VkVertexInputAttributeDescription2EXT *>( pVertexAttributeDescriptions ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setVertexInputEXT( | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT> const & vertexBindingDescriptions, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT> const & vertexAttributeDescriptions, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdSetVertexInputEXT( | |
| m_commandBuffer, | |
| vertexBindingDescriptions.size(), | |
| reinterpret_cast<const VkVertexInputBindingDescription2EXT *>( vertexBindingDescriptions.data() ), | |
| vertexAttributeDescriptions.size(), | |
| reinterpret_cast<const VkVertexInputAttributeDescription2EXT *>( vertexAttributeDescriptions.data() ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #if defined( VK_USE_PLATFORM_FUCHSIA ) | |
| //=== VK_FUCHSIA_external_memory === | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getMemoryZirconHandleFUCHSIA( | |
| const VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo, | |
| zx_handle_t * pZirconHandle, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkGetMemoryZirconHandleFUCHSIA( | |
| m_device, reinterpret_cast<const VkMemoryGetZirconHandleInfoFUCHSIA *>( pGetZirconHandleInfo ), pZirconHandle ) ); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<zx_handle_t>::type | |
| Device::getMemoryZirconHandleFUCHSIA( const MemoryGetZirconHandleInfoFUCHSIA & getZirconHandleInfo, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| zx_handle_t zirconHandle; | |
| Result result = static_cast<Result>( d.vkGetMemoryZirconHandleFUCHSIA( | |
| m_device, reinterpret_cast<const VkMemoryGetZirconHandleInfoFUCHSIA *>( &getZirconHandleInfo ), &zirconHandle ) ); | |
| return createResultValue( | |
| result, zirconHandle, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryZirconHandleFUCHSIA" ); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getMemoryZirconHandlePropertiesFUCHSIA( | |
| VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, | |
| zx_handle_t zirconHandle, | |
| VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA * pMemoryZirconHandleProperties, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkGetMemoryZirconHandlePropertiesFUCHSIA( | |
| m_device, | |
| static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ), | |
| zirconHandle, | |
| reinterpret_cast<VkMemoryZirconHandlePropertiesFUCHSIA *>( pMemoryZirconHandleProperties ) ) ); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA>::type | |
| Device::getMemoryZirconHandlePropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, | |
| zx_handle_t zirconHandle, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA memoryZirconHandleProperties; | |
| Result result = static_cast<Result>( d.vkGetMemoryZirconHandlePropertiesFUCHSIA( | |
| m_device, | |
| static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ), | |
| zirconHandle, | |
| reinterpret_cast<VkMemoryZirconHandlePropertiesFUCHSIA *>( &memoryZirconHandleProperties ) ) ); | |
| return createResultValue( result, | |
| memoryZirconHandleProperties, | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryZirconHandlePropertiesFUCHSIA" ); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #endif /*VK_USE_PLATFORM_FUCHSIA*/ | |
| #if defined( VK_USE_PLATFORM_FUCHSIA ) | |
| //=== VK_FUCHSIA_external_semaphore === | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::importSemaphoreZirconHandleFUCHSIA( | |
| const VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA * pImportSemaphoreZirconHandleInfo, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkImportSemaphoreZirconHandleFUCHSIA( | |
| m_device, | |
| reinterpret_cast<const VkImportSemaphoreZirconHandleInfoFUCHSIA *>( pImportSemaphoreZirconHandleInfo ) ) ); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| Device::importSemaphoreZirconHandleFUCHSIA( | |
| const ImportSemaphoreZirconHandleInfoFUCHSIA & importSemaphoreZirconHandleInfo, Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| Result result = static_cast<Result>( d.vkImportSemaphoreZirconHandleFUCHSIA( | |
| m_device, | |
| reinterpret_cast<const VkImportSemaphoreZirconHandleInfoFUCHSIA *>( &importSemaphoreZirconHandleInfo ) ) ); | |
| return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::importSemaphoreZirconHandleFUCHSIA" ); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSemaphoreZirconHandleFUCHSIA( | |
| const VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo, | |
| zx_handle_t * pZirconHandle, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkGetSemaphoreZirconHandleFUCHSIA( | |
| m_device, | |
| reinterpret_cast<const VkSemaphoreGetZirconHandleInfoFUCHSIA *>( pGetZirconHandleInfo ), | |
| pZirconHandle ) ); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<zx_handle_t>::type | |
| Device::getSemaphoreZirconHandleFUCHSIA( const SemaphoreGetZirconHandleInfoFUCHSIA & getZirconHandleInfo, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| zx_handle_t zirconHandle; | |
| Result result = static_cast<Result>( d.vkGetSemaphoreZirconHandleFUCHSIA( | |
| m_device, | |
| reinterpret_cast<const VkSemaphoreGetZirconHandleInfoFUCHSIA *>( &getZirconHandleInfo ), | |
| &zirconHandle ) ); | |
| return createResultValue( | |
| result, zirconHandle, VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreZirconHandleFUCHSIA" ); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #endif /*VK_USE_PLATFORM_FUCHSIA*/ | |
| //=== VK_HUAWEI_subpass_shading === | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::getSubpassShadingMaxWorkgroupSizeHUAWEI( VULKAN_HPP_NAMESPACE::RenderPass renderpass, | |
| VULKAN_HPP_NAMESPACE::Extent2D * pMaxWorkgroupSize, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( | |
| m_device, static_cast<VkRenderPass>( renderpass ), reinterpret_cast<VkExtent2D *>( pMaxWorkgroupSize ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<VULKAN_HPP_NAMESPACE::Extent2D> | |
| Device::getSubpassShadingMaxWorkgroupSizeHUAWEI( VULKAN_HPP_NAMESPACE::RenderPass renderpass, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::Extent2D maxWorkgroupSize; | |
| Result result = static_cast<Result>( d.vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( | |
| m_device, static_cast<VkRenderPass>( renderpass ), reinterpret_cast<VkExtent2D *>( &maxWorkgroupSize ) ) ); | |
| return createResultValue( result, | |
| maxWorkgroupSize, | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::getSubpassShadingMaxWorkgroupSizeHUAWEI", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eIncomplete } ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::subpassShadingHUAWEI( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdSubpassShadingHUAWEI( m_commandBuffer ); | |
| } | |
| //=== VK_HUAWEI_invocation_mask === | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::bindInvocationMaskHUAWEI( VULKAN_HPP_NAMESPACE::ImageView imageView, | |
| VULKAN_HPP_NAMESPACE::ImageLayout imageLayout, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdBindInvocationMaskHUAWEI( | |
| m_commandBuffer, static_cast<VkImageView>( imageView ), static_cast<VkImageLayout>( imageLayout ) ); | |
| } | |
| //=== VK_NV_external_memory_rdma === | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getMemoryRemoteAddressNV( | |
| const VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV * pMemoryGetRemoteAddressInfo, | |
| VULKAN_HPP_NAMESPACE::RemoteAddressNV * pAddress, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( d.vkGetMemoryRemoteAddressNV( | |
| m_device, | |
| reinterpret_cast<const VkMemoryGetRemoteAddressInfoNV *>( pMemoryGetRemoteAddressInfo ), | |
| reinterpret_cast<VkRemoteAddressNV *>( pAddress ) ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::RemoteAddressNV>::type | |
| Device::getMemoryRemoteAddressNV( const MemoryGetRemoteAddressInfoNV & memoryGetRemoteAddressInfo, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::RemoteAddressNV address; | |
| Result result = static_cast<Result>( d.vkGetMemoryRemoteAddressNV( | |
| m_device, | |
| reinterpret_cast<const VkMemoryGetRemoteAddressInfoNV *>( &memoryGetRemoteAddressInfo ), | |
| reinterpret_cast<VkRemoteAddressNV *>( &address ) ) ); | |
| return createResultValue( result, address, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryRemoteAddressNV" ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_EXT_extended_dynamic_state2 === | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setPatchControlPointsEXT( uint32_t patchControlPoints, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdSetPatchControlPointsEXT( m_commandBuffer, patchControlPoints ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::setRasterizerDiscardEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdSetRasterizerDiscardEnableEXT( m_commandBuffer, static_cast<VkBool32>( rasterizerDiscardEnable ) ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setDepthBiasEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdSetDepthBiasEnableEXT( m_commandBuffer, static_cast<VkBool32>( depthBiasEnable ) ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setLogicOpEXT( VULKAN_HPP_NAMESPACE::LogicOp logicOp, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdSetLogicOpEXT( m_commandBuffer, static_cast<VkLogicOp>( logicOp ) ); | |
| } | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::setPrimitiveRestartEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdSetPrimitiveRestartEnableEXT( m_commandBuffer, static_cast<VkBool32>( primitiveRestartEnable ) ); | |
| } | |
| #if defined( VK_USE_PLATFORM_SCREEN_QNX ) | |
| //=== VK_QNX_screen_surface === | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Instance::createScreenSurfaceQNX( const VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX * pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, | |
| VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Result>( | |
| d.vkCreateScreenSurfaceQNX( m_instance, | |
| reinterpret_cast<const VkScreenSurfaceCreateInfoQNX *>( pCreateInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), | |
| reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) ); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type | |
| Instance::createScreenSurfaceQNX( const ScreenSurfaceCreateInfoQNX & createInfo, | |
| Optional<const AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface; | |
| Result result = static_cast<Result>( | |
| d.vkCreateScreenSurfaceQNX( m_instance, | |
| reinterpret_cast<const VkScreenSurfaceCreateInfoQNX *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkSurfaceKHR *>( &surface ) ) ); | |
| return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createScreenSurfaceQNX" ); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template <typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE | |
| typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type | |
| Instance::createScreenSurfaceQNXUnique( const ScreenSurfaceCreateInfoQNX & createInfo, | |
| Optional<const AllocationCallbacks> allocator, | |
| Dispatch const & d ) const | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface; | |
| Result result = static_cast<Result>( | |
| d.vkCreateScreenSurfaceQNX( m_instance, | |
| reinterpret_cast<const VkScreenSurfaceCreateInfoQNX *>( &createInfo ), | |
| reinterpret_cast<const VkAllocationCallbacks *>( | |
| static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), | |
| reinterpret_cast<VkSurfaceKHR *>( &surface ) ) ); | |
| ObjectDestroy<Instance, Dispatch> deleter( *this, allocator, d ); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>( | |
| result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createScreenSurfaceQNXUnique", deleter ); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE Bool32 PhysicalDevice::getScreenPresentationSupportQNX( | |
| uint32_t queueFamilyIndex, struct _screen_window * window, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return static_cast<Bool32>( | |
| d.vkGetPhysicalDeviceScreenPresentationSupportQNX( m_physicalDevice, queueFamilyIndex, window ) ); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE Bool32 PhysicalDevice::getScreenPresentationSupportQNX( | |
| uint32_t queueFamilyIndex, struct _screen_window & window, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| return d.vkGetPhysicalDeviceScreenPresentationSupportQNX( m_physicalDevice, queueFamilyIndex, &window ); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #endif /*VK_USE_PLATFORM_SCREEN_QNX*/ | |
| //=== VK_EXT_color_write_enable === | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setColorWriteEnableEXT( uint32_t attachmentCount, | |
| const VULKAN_HPP_NAMESPACE::Bool32 * pColorWriteEnables, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdSetColorWriteEnableEXT( | |
| m_commandBuffer, attachmentCount, reinterpret_cast<const VkBool32 *>( pColorWriteEnables ) ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::setColorWriteEnableEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & colorWriteEnables, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdSetColorWriteEnableEXT( | |
| m_commandBuffer, colorWriteEnables.size(), reinterpret_cast<const VkBool32 *>( colorWriteEnables.data() ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_EXT_multi_draw === | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::drawMultiEXT( uint32_t drawCount, | |
| const VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT * pVertexInfo, | |
| uint32_t instanceCount, | |
| uint32_t firstInstance, | |
| uint32_t stride, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdDrawMultiEXT( m_commandBuffer, | |
| drawCount, | |
| reinterpret_cast<const VkMultiDrawInfoEXT *>( pVertexInfo ), | |
| instanceCount, | |
| firstInstance, | |
| stride ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::drawMultiEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT> const & vertexInfo, | |
| uint32_t instanceCount, | |
| uint32_t firstInstance, | |
| uint32_t stride, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdDrawMultiEXT( m_commandBuffer, | |
| vertexInfo.size(), | |
| reinterpret_cast<const VkMultiDrawInfoEXT *>( vertexInfo.data() ), | |
| instanceCount, | |
| firstInstance, | |
| stride ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::drawMultiIndexedEXT( uint32_t drawCount, | |
| const VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT * pIndexInfo, | |
| uint32_t instanceCount, | |
| uint32_t firstInstance, | |
| uint32_t stride, | |
| const int32_t * pVertexOffset, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdDrawMultiIndexedEXT( m_commandBuffer, | |
| drawCount, | |
| reinterpret_cast<const VkMultiDrawIndexedInfoEXT *>( pIndexInfo ), | |
| instanceCount, | |
| firstInstance, | |
| stride, | |
| pVertexOffset ); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template <typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::drawMultiIndexedEXT( | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT> const & indexInfo, | |
| uint32_t instanceCount, | |
| uint32_t firstInstance, | |
| uint32_t stride, | |
| Optional<const int32_t> vertexOffset, | |
| Dispatch const & d ) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); | |
| d.vkCmdDrawMultiIndexedEXT( m_commandBuffer, | |
| indexInfo.size(), | |
| reinterpret_cast<const VkMultiDrawIndexedInfoEXT *>( indexInfo.data() ), | |
| instanceCount, | |
| firstInstance, | |
| stride, | |
| static_cast<const int32_t *>( vertexOffset ) ); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| } // namespace VULKAN_HPP_NAMESPACE | |
| #endif |