| // Copyright 2015-2022 The Khronos Group Inc. | |
| // | |
| // SPDX-License-Identifier: Apache-2.0 OR MIT | |
| // | |
| // This header is generated from the Khronos Vulkan XML API Registry. | |
| #ifndef VULKAN_FUNCS_HPP | |
| #define VULKAN_FUNCS_HPP | |
| namespace VULKAN_HPP_NAMESPACE { | |
| //=========================== | |
| //=== COMMAND Definitions === | |
| //=========================== | |
| //=== VK_VERSION_1_0 === | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result createInstance(const VULKAN_HPP_NAMESPACE::InstanceCreateInfo *pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| VULKAN_HPP_NAMESPACE::Instance *pInstance, | |
| Dispatch const &d) VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkCreateInstance(reinterpret_cast<const VkInstanceCreateInfo *>(pCreateInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(pAllocator), | |
| reinterpret_cast<VkInstance *>(pInstance))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::Instance>::type createInstance( | |
| const VULKAN_HPP_NAMESPACE::InstanceCreateInfo &createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, Dispatch const &d) | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::Instance instance; | |
| VkResult result = | |
| d.vkCreateInstance(reinterpret_cast<const VkInstanceCreateInfo *>(&createInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)), | |
| reinterpret_cast<VkInstance *>(&instance)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::createInstance"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), instance); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Instance, Dispatch>>::type createInstanceUnique( | |
| const VULKAN_HPP_NAMESPACE::InstanceCreateInfo &createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, Dispatch const &d) | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::Instance instance; | |
| Result result = static_cast<Result>( | |
| d.vkCreateInstance(reinterpret_cast<const VkInstanceCreateInfo *>(&createInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)), | |
| reinterpret_cast<VkInstance *>(&instance))); | |
| ObjectDestroy<NoParent, Dispatch> deleter(allocator, d); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::Instance, Dispatch>(result, instance, VULKAN_HPP_NAMESPACE_STRING "::createInstanceUnique", deleter); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Instance::destroy(const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyInstance(m_instance, reinterpret_cast<const VkAllocationCallbacks *>(pAllocator)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Instance::destroy(Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyInstance(m_instance, | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::enumeratePhysicalDevices(uint32_t *pPhysicalDeviceCount, | |
| VULKAN_HPP_NAMESPACE::PhysicalDevice *pPhysicalDevices, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkEnumeratePhysicalDevices(m_instance, pPhysicalDeviceCount, reinterpret_cast<VkPhysicalDevice *>(pPhysicalDevices))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename PhysicalDeviceAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<PhysicalDevice, PhysicalDeviceAllocator>>::type | |
| Instance::enumeratePhysicalDevices(Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| std::vector<PhysicalDevice, PhysicalDeviceAllocator> physicalDevices; | |
| uint32_t physicalDeviceCount; | |
| Result result; | |
| do | |
| { | |
| result = static_cast<Result>(d.vkEnumeratePhysicalDevices(m_instance, &physicalDeviceCount, nullptr)); | |
| if((result == Result::eSuccess) && physicalDeviceCount) | |
| { | |
| physicalDevices.resize(physicalDeviceCount); | |
| result = static_cast<Result>( | |
| d.vkEnumeratePhysicalDevices(m_instance, &physicalDeviceCount, reinterpret_cast<VkPhysicalDevice *>(physicalDevices.data()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(physicalDeviceCount <= physicalDevices.size()); | |
| if(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()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(physicalDeviceCount <= physicalDevices.size()); | |
| if(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 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; | |
| VkResult 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)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), imageFormatProperties); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void PhysicalDevice::getProperties(VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties *pProperties, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkGetPhysicalDeviceProperties(m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties *>(pProperties)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties | |
| PhysicalDevice::getProperties(Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| 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); | |
| PFN_vkVoidFunction result = d.vkGetInstanceProcAddr(m_instance, name.c_str()); | |
| return result; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE PFN_vkVoidFunction Device::getProcAddr(const char *pName, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return d.vkGetDeviceProcAddr(m_device, pName); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE PFN_vkVoidFunction Device::getProcAddr(const std::string &name, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| PFN_vkVoidFunction result = d.vkGetDeviceProcAddr(m_device, name.c_str()); | |
| return result; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::createDevice(const VULKAN_HPP_NAMESPACE::DeviceCreateInfo *pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| VULKAN_HPP_NAMESPACE::Device *pDevice, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkCreateDevice(m_physicalDevice, | |
| reinterpret_cast<const VkDeviceCreateInfo *>(pCreateInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(pAllocator), | |
| reinterpret_cast<VkDevice *>(pDevice))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::Device>::type PhysicalDevice::createDevice( | |
| const VULKAN_HPP_NAMESPACE::DeviceCreateInfo &createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::Device device; | |
| VkResult 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)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::createDevice"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), device); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Device, Dispatch>>::type | |
| PhysicalDevice::createDeviceUnique(const VULKAN_HPP_NAMESPACE::DeviceCreateInfo &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::Device device; | |
| Result result = static_cast<Result>( | |
| d.vkCreateDevice(m_physicalDevice, | |
| reinterpret_cast<const VkDeviceCreateInfo *>(&createInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)), | |
| reinterpret_cast<VkDevice *>(&device))); | |
| ObjectDestroy<NoParent, Dispatch> deleter(allocator, d); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::Device, Dispatch>( | |
| result, device, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::createDeviceUnique", deleter); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy(const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyDevice(m_device, reinterpret_cast<const VkAllocationCallbacks *>(pAllocator)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy(Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyDevice(m_device, | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result enumerateInstanceExtensionProperties(const char *pLayerName, | |
| uint32_t *pPropertyCount, | |
| VULKAN_HPP_NAMESPACE::ExtensionProperties *pProperties, | |
| Dispatch const &d) VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>( | |
| d.vkEnumerateInstanceExtensionProperties(pLayerName, pPropertyCount, reinterpret_cast<VkExtensionProperties *>(pProperties))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename ExtensionPropertiesAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<ExtensionProperties, ExtensionPropertiesAllocator>>::type | |
| enumerateInstanceExtensionProperties(Optional<const std::string> layerName, Dispatch const &d) | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| std::vector<ExtensionProperties, ExtensionPropertiesAllocator> properties; | |
| uint32_t propertyCount; | |
| Result result; | |
| do | |
| { | |
| result = static_cast<Result>(d.vkEnumerateInstanceExtensionProperties(layerName ? layerName->c_str() : nullptr, &propertyCount, nullptr)); | |
| if((result == Result::eSuccess) && propertyCount) | |
| { | |
| properties.resize(propertyCount); | |
| result = static_cast<Result>(d.vkEnumerateInstanceExtensionProperties( | |
| layerName ? layerName->c_str() : nullptr, &propertyCount, reinterpret_cast<VkExtensionProperties *>(properties.data()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(propertyCount <= properties.size()); | |
| if(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()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(propertyCount <= properties.size()); | |
| if(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()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(propertyCount <= properties.size()); | |
| if(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()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(propertyCount <= properties.size()); | |
| if(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()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(propertyCount <= properties.size()); | |
| if(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()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(propertyCount <= properties.size()); | |
| if(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()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(propertyCount <= properties.size()); | |
| if(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()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(propertyCount <= properties.size()); | |
| if(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); | |
| VkResult result = d.vkQueueSubmit(m_queue, submits.size(), reinterpret_cast<const VkSubmitInfo *>(submits.data()), static_cast<VkFence>(fence)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Queue::submit"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result 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); | |
| VkResult result = d.vkQueueWaitIdle(m_queue); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Queue::waitIdle"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::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); | |
| VkResult result = d.vkDeviceWaitIdle(m_device); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::waitIdle"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::allocateMemory(const VULKAN_HPP_NAMESPACE::MemoryAllocateInfo *pAllocateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| VULKAN_HPP_NAMESPACE::DeviceMemory *pMemory, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkAllocateMemory(m_device, | |
| reinterpret_cast<const VkMemoryAllocateInfo *>(pAllocateInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(pAllocator), | |
| reinterpret_cast<VkDeviceMemory *>(pMemory))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceMemory>::type | |
| Device::allocateMemory(const VULKAN_HPP_NAMESPACE::MemoryAllocateInfo &allocateInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::DeviceMemory memory; | |
| VkResult 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)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::allocateMemory"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), memory); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DeviceMemory, Dispatch>>::type | |
| Device::allocateMemoryUnique(const VULKAN_HPP_NAMESPACE::MemoryAllocateInfo &allocateInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::DeviceMemory memory; | |
| Result result = static_cast<Result>( | |
| d.vkAllocateMemory(m_device, | |
| reinterpret_cast<const VkMemoryAllocateInfo *>(&allocateInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)), | |
| reinterpret_cast<VkDeviceMemory *>(&memory))); | |
| ObjectFree<Device, Dispatch> deleter(*this, allocator, d); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::DeviceMemory, Dispatch>( | |
| result, memory, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateMemoryUnique", deleter); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::freeMemory(VULKAN_HPP_NAMESPACE::DeviceMemory memory, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkFreeMemory(m_device, static_cast<VkDeviceMemory>(memory), reinterpret_cast<const VkAllocationCallbacks *>(pAllocator)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::freeMemory(VULKAN_HPP_NAMESPACE::DeviceMemory memory, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkFreeMemory(m_device, | |
| static_cast<VkDeviceMemory>(memory), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void(Device::free)(VULKAN_HPP_NAMESPACE::DeviceMemory memory, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkFreeMemory(m_device, static_cast<VkDeviceMemory>(memory), reinterpret_cast<const VkAllocationCallbacks *>(pAllocator)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void(Device::free)(VULKAN_HPP_NAMESPACE::DeviceMemory memory, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkFreeMemory(m_device, | |
| static_cast<VkDeviceMemory>(memory), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::mapMemory(VULKAN_HPP_NAMESPACE::DeviceMemory memory, | |
| VULKAN_HPP_NAMESPACE::DeviceSize offset, | |
| VULKAN_HPP_NAMESPACE::DeviceSize size, | |
| VULKAN_HPP_NAMESPACE::MemoryMapFlags flags, | |
| void **ppData, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkMapMemory(m_device, | |
| static_cast<VkDeviceMemory>(memory), | |
| static_cast<VkDeviceSize>(offset), | |
| static_cast<VkDeviceSize>(size), | |
| static_cast<VkMemoryMapFlags>(flags), | |
| ppData)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD 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; | |
| VkResult result = d.vkMapMemory(m_device, | |
| static_cast<VkDeviceMemory>(memory), | |
| static_cast<VkDeviceSize>(offset), | |
| static_cast<VkDeviceSize>(size), | |
| static_cast<VkMemoryMapFlags>(flags), | |
| &pData); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::mapMemory"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), pData); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::unmapMemory(VULKAN_HPP_NAMESPACE::DeviceMemory memory, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkUnmapMemory(m_device, static_cast<VkDeviceMemory>(memory)); | |
| } | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::flushMappedMemoryRanges(uint32_t memoryRangeCount, | |
| const VULKAN_HPP_NAMESPACE::MappedMemoryRange *pMemoryRanges, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkFlushMappedMemoryRanges(m_device, memoryRangeCount, reinterpret_cast<const VkMappedMemoryRange *>(pMemoryRanges))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| Device::flushMappedMemoryRanges(ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const &memoryRanges, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VkResult result = d.vkFlushMappedMemoryRanges(m_device, memoryRanges.size(), reinterpret_cast<const VkMappedMemoryRange *>(memoryRanges.data())); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::flushMappedMemoryRanges"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::invalidateMappedMemoryRanges(uint32_t memoryRangeCount, | |
| const VULKAN_HPP_NAMESPACE::MappedMemoryRange *pMemoryRanges, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>( | |
| d.vkInvalidateMappedMemoryRanges(m_device, memoryRangeCount, reinterpret_cast<const VkMappedMemoryRange *>(pMemoryRanges))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| Device::invalidateMappedMemoryRanges(ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const &memoryRanges, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VkResult result = d.vkInvalidateMappedMemoryRanges(m_device, memoryRanges.size(), reinterpret_cast<const VkMappedMemoryRange *>(memoryRanges.data())); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::invalidateMappedMemoryRanges"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::getMemoryCommitment(VULKAN_HPP_NAMESPACE::DeviceMemory memory, | |
| VULKAN_HPP_NAMESPACE::DeviceSize *pCommittedMemoryInBytes, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkGetDeviceMemoryCommitment(m_device, static_cast<VkDeviceMemory>(memory), reinterpret_cast<VkDeviceSize *>(pCommittedMemoryInBytes)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceSize Device::getMemoryCommitment(VULKAN_HPP_NAMESPACE::DeviceMemory memory, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| 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); | |
| VkResult result = | |
| d.vkBindBufferMemory(m_device, static_cast<VkBuffer>(buffer), static_cast<VkDeviceMemory>(memory), static_cast<VkDeviceSize>(memoryOffset)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::bindBufferMemory"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::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); | |
| VkResult result = | |
| d.vkBindImageMemory(m_device, static_cast<VkImage>(image), static_cast<VkDeviceMemory>(memory), static_cast<VkDeviceSize>(memoryOffset)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::bindImageMemory"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::getBufferMemoryRequirements(VULKAN_HPP_NAMESPACE::Buffer buffer, | |
| VULKAN_HPP_NAMESPACE::MemoryRequirements *pMemoryRequirements, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkGetBufferMemoryRequirements(m_device, static_cast<VkBuffer>(buffer), reinterpret_cast<VkMemoryRequirements *>(pMemoryRequirements)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements | |
| Device::getBufferMemoryRequirements(VULKAN_HPP_NAMESPACE::Buffer buffer, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| 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); | |
| VkResult result = | |
| d.vkQueueBindSparse(m_queue, bindInfo.size(), reinterpret_cast<const VkBindSparseInfo *>(bindInfo.data()), static_cast<VkFence>(fence)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Queue::bindSparse"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createFence(const VULKAN_HPP_NAMESPACE::FenceCreateInfo *pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| VULKAN_HPP_NAMESPACE::Fence *pFence, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkCreateFence(m_device, | |
| reinterpret_cast<const VkFenceCreateInfo *>(pCreateInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(pAllocator), | |
| reinterpret_cast<VkFence *>(pFence))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::Fence>::type Device::createFence( | |
| const VULKAN_HPP_NAMESPACE::FenceCreateInfo &createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::Fence fence; | |
| VkResult 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)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::createFence"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), fence); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>>::type Device::createFenceUnique( | |
| const VULKAN_HPP_NAMESPACE::FenceCreateInfo &createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::Fence fence; | |
| Result result = static_cast<Result>( | |
| d.vkCreateFence(m_device, | |
| reinterpret_cast<const VkFenceCreateInfo *>(&createInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)), | |
| reinterpret_cast<VkFence *>(&fence))); | |
| ObjectDestroy<Device, Dispatch> deleter(*this, allocator, d); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::Fence, Dispatch>(result, fence, VULKAN_HPP_NAMESPACE_STRING "::Device::createFenceUnique", deleter); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroyFence(VULKAN_HPP_NAMESPACE::Fence fence, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyFence(m_device, static_cast<VkFence>(fence), reinterpret_cast<const VkAllocationCallbacks *>(pAllocator)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroyFence(VULKAN_HPP_NAMESPACE::Fence fence, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyFence(m_device, | |
| static_cast<VkFence>(fence), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy(VULKAN_HPP_NAMESPACE::Fence fence, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyFence(m_device, static_cast<VkFence>(fence), reinterpret_cast<const VkAllocationCallbacks *>(pAllocator)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy(VULKAN_HPP_NAMESPACE::Fence fence, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyFence(m_device, | |
| static_cast<VkFence>(fence), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::resetFences(uint32_t fenceCount, | |
| const VULKAN_HPP_NAMESPACE::Fence *pFences, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkResetFences(m_device, fenceCount, reinterpret_cast<const VkFence *>(pFences))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::resetFences(ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const &fences, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VkResult result = d.vkResetFences(m_device, fences.size(), reinterpret_cast<const VkFence *>(fences.data())); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::resetFences"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getFenceStatus(VULKAN_HPP_NAMESPACE::Fence fence, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkGetFenceStatus(m_device, static_cast<VkFence>(fence))); | |
| } | |
| #else | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result Device::getFenceStatus(VULKAN_HPP_NAMESPACE::Fence fence, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VkResult result = d.vkGetFenceStatus(m_device, static_cast<VkFence>(fence)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::getFenceStatus", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eNotReady }); | |
| return static_cast<VULKAN_HPP_NAMESPACE::Result>(result); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::waitForFences(uint32_t fenceCount, | |
| const VULKAN_HPP_NAMESPACE::Fence *pFences, | |
| VULKAN_HPP_NAMESPACE::Bool32 waitAll, | |
| uint64_t timeout, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>( | |
| d.vkWaitForFences(m_device, fenceCount, reinterpret_cast<const VkFence *>(pFences), static_cast<VkBool32>(waitAll), timeout)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result Device::waitForFences(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); | |
| VkResult result = | |
| d.vkWaitForFences(m_device, fences.size(), reinterpret_cast<const VkFence *>(fences.data()), static_cast<VkBool32>(waitAll), timeout); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::waitForFences", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eTimeout }); | |
| return static_cast<VULKAN_HPP_NAMESPACE::Result>(result); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createSemaphore(const VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo *pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| VULKAN_HPP_NAMESPACE::Semaphore *pSemaphore, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkCreateSemaphore(m_device, | |
| reinterpret_cast<const VkSemaphoreCreateInfo *>(pCreateInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(pAllocator), | |
| reinterpret_cast<VkSemaphore *>(pSemaphore))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::Semaphore>::type | |
| Device::createSemaphore(const VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::Semaphore semaphore; | |
| VkResult 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)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::createSemaphore"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), semaphore); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Semaphore, Dispatch>>::type | |
| Device::createSemaphoreUnique(const VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::Semaphore semaphore; | |
| Result result = static_cast<Result>( | |
| d.vkCreateSemaphore(m_device, | |
| reinterpret_cast<const VkSemaphoreCreateInfo *>(&createInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)), | |
| reinterpret_cast<VkSemaphore *>(&semaphore))); | |
| ObjectDestroy<Device, Dispatch> deleter(*this, allocator, d); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::Semaphore, Dispatch>( | |
| result, semaphore, VULKAN_HPP_NAMESPACE_STRING "::Device::createSemaphoreUnique", deleter); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroySemaphore(VULKAN_HPP_NAMESPACE::Semaphore semaphore, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroySemaphore(m_device, static_cast<VkSemaphore>(semaphore), reinterpret_cast<const VkAllocationCallbacks *>(pAllocator)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroySemaphore(VULKAN_HPP_NAMESPACE::Semaphore semaphore, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroySemaphore(m_device, | |
| static_cast<VkSemaphore>(semaphore), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy(VULKAN_HPP_NAMESPACE::Semaphore semaphore, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroySemaphore(m_device, static_cast<VkSemaphore>(semaphore), reinterpret_cast<const VkAllocationCallbacks *>(pAllocator)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy(VULKAN_HPP_NAMESPACE::Semaphore semaphore, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroySemaphore(m_device, | |
| static_cast<VkSemaphore>(semaphore), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createEvent(const VULKAN_HPP_NAMESPACE::EventCreateInfo *pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| VULKAN_HPP_NAMESPACE::Event *pEvent, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkCreateEvent(m_device, | |
| reinterpret_cast<const VkEventCreateInfo *>(pCreateInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(pAllocator), | |
| reinterpret_cast<VkEvent *>(pEvent))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::Event>::type Device::createEvent( | |
| const VULKAN_HPP_NAMESPACE::EventCreateInfo &createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::Event event; | |
| VkResult 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)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::createEvent"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), event); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Event, Dispatch>>::type Device::createEventUnique( | |
| const VULKAN_HPP_NAMESPACE::EventCreateInfo &createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::Event event; | |
| Result result = static_cast<Result>( | |
| d.vkCreateEvent(m_device, | |
| reinterpret_cast<const VkEventCreateInfo *>(&createInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)), | |
| reinterpret_cast<VkEvent *>(&event))); | |
| ObjectDestroy<Device, Dispatch> deleter(*this, allocator, d); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::Event, Dispatch>(result, event, VULKAN_HPP_NAMESPACE_STRING "::Device::createEventUnique", deleter); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroyEvent(VULKAN_HPP_NAMESPACE::Event event, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyEvent(m_device, static_cast<VkEvent>(event), reinterpret_cast<const VkAllocationCallbacks *>(pAllocator)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroyEvent(VULKAN_HPP_NAMESPACE::Event event, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyEvent(m_device, | |
| static_cast<VkEvent>(event), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy(VULKAN_HPP_NAMESPACE::Event event, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyEvent(m_device, static_cast<VkEvent>(event), reinterpret_cast<const VkAllocationCallbacks *>(pAllocator)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy(VULKAN_HPP_NAMESPACE::Event event, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyEvent(m_device, | |
| static_cast<VkEvent>(event), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getEventStatus(VULKAN_HPP_NAMESPACE::Event event, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkGetEventStatus(m_device, static_cast<VkEvent>(event))); | |
| } | |
| #else | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result Device::getEventStatus(VULKAN_HPP_NAMESPACE::Event event, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VkResult result = d.vkGetEventStatus(m_device, static_cast<VkEvent>(event)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::getEventStatus", | |
| { VULKAN_HPP_NAMESPACE::Result::eEventSet, VULKAN_HPP_NAMESPACE::Result::eEventReset }); | |
| return static_cast<VULKAN_HPP_NAMESPACE::Result>(result); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::setEvent(VULKAN_HPP_NAMESPACE::Event event, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkSetEvent(m_device, static_cast<VkEvent>(event))); | |
| } | |
| #else | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::setEvent(VULKAN_HPP_NAMESPACE::Event event, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VkResult result = d.vkSetEvent(m_device, static_cast<VkEvent>(event)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::setEvent"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::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); | |
| VkResult result = d.vkResetEvent(m_device, static_cast<VkEvent>(event)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::resetEvent"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createQueryPool(const VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo *pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| VULKAN_HPP_NAMESPACE::QueryPool *pQueryPool, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkCreateQueryPool(m_device, | |
| reinterpret_cast<const VkQueryPoolCreateInfo *>(pCreateInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(pAllocator), | |
| reinterpret_cast<VkQueryPool *>(pQueryPool))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::QueryPool>::type | |
| Device::createQueryPool(const VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::QueryPool queryPool; | |
| VkResult 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)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::createQueryPool"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), queryPool); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::QueryPool, Dispatch>>::type | |
| Device::createQueryPoolUnique(const VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::QueryPool queryPool; | |
| Result result = static_cast<Result>( | |
| d.vkCreateQueryPool(m_device, | |
| reinterpret_cast<const VkQueryPoolCreateInfo *>(&createInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)), | |
| reinterpret_cast<VkQueryPool *>(&queryPool))); | |
| ObjectDestroy<Device, Dispatch> deleter(*this, allocator, d); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::QueryPool, Dispatch>( | |
| result, queryPool, VULKAN_HPP_NAMESPACE_STRING "::Device::createQueryPoolUnique", deleter); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroyQueryPool(VULKAN_HPP_NAMESPACE::QueryPool queryPool, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyQueryPool(m_device, static_cast<VkQueryPool>(queryPool), reinterpret_cast<const VkAllocationCallbacks *>(pAllocator)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroyQueryPool(VULKAN_HPP_NAMESPACE::QueryPool queryPool, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyQueryPool(m_device, | |
| static_cast<VkQueryPool>(queryPool), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy(VULKAN_HPP_NAMESPACE::QueryPool queryPool, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyQueryPool(m_device, static_cast<VkQueryPool>(queryPool), reinterpret_cast<const VkAllocationCallbacks *>(pAllocator)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy(VULKAN_HPP_NAMESPACE::QueryPool queryPool, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyQueryPool(m_device, | |
| static_cast<VkQueryPool>(queryPool), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getQueryPoolResults(VULKAN_HPP_NAMESPACE::QueryPool queryPool, | |
| uint32_t firstQuery, | |
| uint32_t queryCount, | |
| size_t dataSize, | |
| void *pData, | |
| VULKAN_HPP_NAMESPACE::DeviceSize stride, | |
| VULKAN_HPP_NAMESPACE::QueryResultFlags flags, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkGetQueryPoolResults(m_device, | |
| static_cast<VkQueryPool>(queryPool), | |
| firstQuery, | |
| queryCount, | |
| dataSize, | |
| pData, | |
| static_cast<VkDeviceSize>(stride), | |
| static_cast<VkQueryResultFlags>(flags))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename DataType, typename DataTypeAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<DataType, DataTypeAllocator>> | |
| Device::getQueryPoolResults(VULKAN_HPP_NAMESPACE::QueryPool queryPool, | |
| uint32_t firstQuery, | |
| uint32_t queryCount, | |
| size_t dataSize, | |
| VULKAN_HPP_NAMESPACE::DeviceSize stride, | |
| VULKAN_HPP_NAMESPACE::QueryResultFlags flags, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_ASSERT(dataSize % sizeof(DataType) == 0); | |
| std::vector<DataType, DataTypeAllocator> data(dataSize / sizeof(DataType)); | |
| Result result = static_cast<Result>(d.vkGetQueryPoolResults(m_device, | |
| static_cast<VkQueryPool>(queryPool), | |
| firstQuery, | |
| queryCount, | |
| data.size() * sizeof(DataType), | |
| reinterpret_cast<void *>(data.data()), | |
| static_cast<VkDeviceSize>(stride), | |
| static_cast<VkQueryResultFlags>(flags))); | |
| return createResultValue(result, | |
| data, | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::getQueryPoolResults", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eNotReady }); | |
| } | |
| template<typename DataType, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<DataType> Device::getQueryPoolResult(VULKAN_HPP_NAMESPACE::QueryPool queryPool, | |
| uint32_t firstQuery, | |
| uint32_t queryCount, | |
| VULKAN_HPP_NAMESPACE::DeviceSize stride, | |
| VULKAN_HPP_NAMESPACE::QueryResultFlags flags, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| DataType data; | |
| VkResult result = d.vkGetQueryPoolResults(m_device, | |
| static_cast<VkQueryPool>(queryPool), | |
| firstQuery, | |
| queryCount, | |
| sizeof(DataType), | |
| reinterpret_cast<void *>(&data), | |
| static_cast<VkDeviceSize>(stride), | |
| static_cast<VkQueryResultFlags>(flags)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::getQueryPoolResult", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eNotReady }); | |
| return ResultValue<DataType>(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), data); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createBuffer(const VULKAN_HPP_NAMESPACE::BufferCreateInfo *pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| VULKAN_HPP_NAMESPACE::Buffer *pBuffer, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkCreateBuffer(m_device, | |
| reinterpret_cast<const VkBufferCreateInfo *>(pCreateInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(pAllocator), | |
| reinterpret_cast<VkBuffer *>(pBuffer))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::Buffer>::type Device::createBuffer( | |
| const VULKAN_HPP_NAMESPACE::BufferCreateInfo &createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::Buffer buffer; | |
| VkResult 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)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::createBuffer"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), buffer); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Buffer, Dispatch>>::type Device::createBufferUnique( | |
| const VULKAN_HPP_NAMESPACE::BufferCreateInfo &createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::Buffer buffer; | |
| Result result = static_cast<Result>( | |
| d.vkCreateBuffer(m_device, | |
| reinterpret_cast<const VkBufferCreateInfo *>(&createInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)), | |
| reinterpret_cast<VkBuffer *>(&buffer))); | |
| ObjectDestroy<Device, Dispatch> deleter(*this, allocator, d); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::Buffer, Dispatch>(result, buffer, VULKAN_HPP_NAMESPACE_STRING "::Device::createBufferUnique", deleter); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroyBuffer(VULKAN_HPP_NAMESPACE::Buffer buffer, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyBuffer(m_device, static_cast<VkBuffer>(buffer), reinterpret_cast<const VkAllocationCallbacks *>(pAllocator)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroyBuffer(VULKAN_HPP_NAMESPACE::Buffer buffer, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyBuffer(m_device, | |
| static_cast<VkBuffer>(buffer), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy(VULKAN_HPP_NAMESPACE::Buffer buffer, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyBuffer(m_device, static_cast<VkBuffer>(buffer), reinterpret_cast<const VkAllocationCallbacks *>(pAllocator)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy(VULKAN_HPP_NAMESPACE::Buffer buffer, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyBuffer(m_device, | |
| static_cast<VkBuffer>(buffer), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createBufferView(const VULKAN_HPP_NAMESPACE::BufferViewCreateInfo *pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| VULKAN_HPP_NAMESPACE::BufferView *pView, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkCreateBufferView(m_device, | |
| reinterpret_cast<const VkBufferViewCreateInfo *>(pCreateInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(pAllocator), | |
| reinterpret_cast<VkBufferView *>(pView))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::BufferView>::type | |
| Device::createBufferView(const VULKAN_HPP_NAMESPACE::BufferViewCreateInfo &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::BufferView view; | |
| VkResult 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)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::createBufferView"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), view); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::BufferView, Dispatch>>::type | |
| Device::createBufferViewUnique(const VULKAN_HPP_NAMESPACE::BufferViewCreateInfo &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::BufferView view; | |
| Result result = static_cast<Result>( | |
| d.vkCreateBufferView(m_device, | |
| reinterpret_cast<const VkBufferViewCreateInfo *>(&createInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)), | |
| reinterpret_cast<VkBufferView *>(&view))); | |
| ObjectDestroy<Device, Dispatch> deleter(*this, allocator, d); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::BufferView, Dispatch>( | |
| result, view, VULKAN_HPP_NAMESPACE_STRING "::Device::createBufferViewUnique", deleter); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroyBufferView(VULKAN_HPP_NAMESPACE::BufferView bufferView, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyBufferView(m_device, static_cast<VkBufferView>(bufferView), reinterpret_cast<const VkAllocationCallbacks *>(pAllocator)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroyBufferView(VULKAN_HPP_NAMESPACE::BufferView bufferView, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyBufferView(m_device, | |
| static_cast<VkBufferView>(bufferView), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy(VULKAN_HPP_NAMESPACE::BufferView bufferView, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyBufferView(m_device, static_cast<VkBufferView>(bufferView), reinterpret_cast<const VkAllocationCallbacks *>(pAllocator)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy(VULKAN_HPP_NAMESPACE::BufferView bufferView, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyBufferView(m_device, | |
| static_cast<VkBufferView>(bufferView), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createImage(const VULKAN_HPP_NAMESPACE::ImageCreateInfo *pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| VULKAN_HPP_NAMESPACE::Image *pImage, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkCreateImage(m_device, | |
| reinterpret_cast<const VkImageCreateInfo *>(pCreateInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(pAllocator), | |
| reinterpret_cast<VkImage *>(pImage))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::Image>::type Device::createImage( | |
| const VULKAN_HPP_NAMESPACE::ImageCreateInfo &createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::Image image; | |
| VkResult 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)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::createImage"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), image); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Image, Dispatch>>::type Device::createImageUnique( | |
| const VULKAN_HPP_NAMESPACE::ImageCreateInfo &createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::Image image; | |
| Result result = static_cast<Result>( | |
| d.vkCreateImage(m_device, | |
| reinterpret_cast<const VkImageCreateInfo *>(&createInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)), | |
| reinterpret_cast<VkImage *>(&image))); | |
| ObjectDestroy<Device, Dispatch> deleter(*this, allocator, d); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::Image, Dispatch>(result, image, VULKAN_HPP_NAMESPACE_STRING "::Device::createImageUnique", deleter); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroyImage(VULKAN_HPP_NAMESPACE::Image image, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyImage(m_device, static_cast<VkImage>(image), reinterpret_cast<const VkAllocationCallbacks *>(pAllocator)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroyImage(VULKAN_HPP_NAMESPACE::Image image, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyImage(m_device, | |
| static_cast<VkImage>(image), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy(VULKAN_HPP_NAMESPACE::Image image, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyImage(m_device, static_cast<VkImage>(image), reinterpret_cast<const VkAllocationCallbacks *>(pAllocator)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy(VULKAN_HPP_NAMESPACE::Image image, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyImage(m_device, | |
| static_cast<VkImage>(image), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::getImageSubresourceLayout(VULKAN_HPP_NAMESPACE::Image image, | |
| const VULKAN_HPP_NAMESPACE::ImageSubresource *pSubresource, | |
| VULKAN_HPP_NAMESPACE::SubresourceLayout *pLayout, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkGetImageSubresourceLayout(m_device, | |
| static_cast<VkImage>(image), | |
| reinterpret_cast<const VkImageSubresource *>(pSubresource), | |
| reinterpret_cast<VkSubresourceLayout *>(pLayout)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::SubresourceLayout Device::getImageSubresourceLayout( | |
| VULKAN_HPP_NAMESPACE::Image image, const VULKAN_HPP_NAMESPACE::ImageSubresource &subresource, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::SubresourceLayout layout; | |
| d.vkGetImageSubresourceLayout(m_device, | |
| static_cast<VkImage>(image), | |
| reinterpret_cast<const VkImageSubresource *>(&subresource), | |
| reinterpret_cast<VkSubresourceLayout *>(&layout)); | |
| return layout; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createImageView(const VULKAN_HPP_NAMESPACE::ImageViewCreateInfo *pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| VULKAN_HPP_NAMESPACE::ImageView *pView, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkCreateImageView(m_device, | |
| reinterpret_cast<const VkImageViewCreateInfo *>(pCreateInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(pAllocator), | |
| reinterpret_cast<VkImageView *>(pView))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageView>::type | |
| Device::createImageView(const VULKAN_HPP_NAMESPACE::ImageViewCreateInfo &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::ImageView view; | |
| VkResult 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)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::createImageView"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), view); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ImageView, Dispatch>>::type | |
| Device::createImageViewUnique(const VULKAN_HPP_NAMESPACE::ImageViewCreateInfo &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::ImageView view; | |
| Result result = static_cast<Result>( | |
| d.vkCreateImageView(m_device, | |
| reinterpret_cast<const VkImageViewCreateInfo *>(&createInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)), | |
| reinterpret_cast<VkImageView *>(&view))); | |
| ObjectDestroy<Device, Dispatch> deleter(*this, allocator, d); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::ImageView, Dispatch>(result, view, VULKAN_HPP_NAMESPACE_STRING "::Device::createImageViewUnique", deleter); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroyImageView(VULKAN_HPP_NAMESPACE::ImageView imageView, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyImageView(m_device, static_cast<VkImageView>(imageView), reinterpret_cast<const VkAllocationCallbacks *>(pAllocator)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroyImageView(VULKAN_HPP_NAMESPACE::ImageView imageView, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyImageView(m_device, | |
| static_cast<VkImageView>(imageView), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy(VULKAN_HPP_NAMESPACE::ImageView imageView, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyImageView(m_device, static_cast<VkImageView>(imageView), reinterpret_cast<const VkAllocationCallbacks *>(pAllocator)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy(VULKAN_HPP_NAMESPACE::ImageView imageView, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyImageView(m_device, | |
| static_cast<VkImageView>(imageView), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createShaderModule(const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo *pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| VULKAN_HPP_NAMESPACE::ShaderModule *pShaderModule, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkCreateShaderModule(m_device, | |
| reinterpret_cast<const VkShaderModuleCreateInfo *>(pCreateInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(pAllocator), | |
| reinterpret_cast<VkShaderModule *>(pShaderModule))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::ShaderModule>::type | |
| Device::createShaderModule(const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::ShaderModule shaderModule; | |
| VkResult 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)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::createShaderModule"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), shaderModule); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderModule, Dispatch>>::type | |
| Device::createShaderModuleUnique(const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::ShaderModule shaderModule; | |
| Result result = static_cast<Result>( | |
| d.vkCreateShaderModule(m_device, | |
| reinterpret_cast<const VkShaderModuleCreateInfo *>(&createInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)), | |
| reinterpret_cast<VkShaderModule *>(&shaderModule))); | |
| ObjectDestroy<Device, Dispatch> deleter(*this, allocator, d); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::ShaderModule, Dispatch>( | |
| result, shaderModule, VULKAN_HPP_NAMESPACE_STRING "::Device::createShaderModuleUnique", deleter); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroyShaderModule(VULKAN_HPP_NAMESPACE::ShaderModule shaderModule, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyShaderModule(m_device, static_cast<VkShaderModule>(shaderModule), reinterpret_cast<const VkAllocationCallbacks *>(pAllocator)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroyShaderModule(VULKAN_HPP_NAMESPACE::ShaderModule shaderModule, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyShaderModule(m_device, | |
| static_cast<VkShaderModule>(shaderModule), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy(VULKAN_HPP_NAMESPACE::ShaderModule shaderModule, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyShaderModule(m_device, static_cast<VkShaderModule>(shaderModule), reinterpret_cast<const VkAllocationCallbacks *>(pAllocator)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy(VULKAN_HPP_NAMESPACE::ShaderModule shaderModule, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyShaderModule(m_device, | |
| static_cast<VkShaderModule>(shaderModule), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createPipelineCache(const VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo *pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| VULKAN_HPP_NAMESPACE::PipelineCache *pPipelineCache, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkCreatePipelineCache(m_device, | |
| reinterpret_cast<const VkPipelineCacheCreateInfo *>(pCreateInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(pAllocator), | |
| reinterpret_cast<VkPipelineCache *>(pPipelineCache))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::PipelineCache>::type | |
| Device::createPipelineCache(const VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache; | |
| VkResult 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)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineCache"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), pipelineCache); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineCache, Dispatch>>::type | |
| Device::createPipelineCacheUnique(const VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache; | |
| Result result = static_cast<Result>( | |
| d.vkCreatePipelineCache(m_device, | |
| reinterpret_cast<const VkPipelineCacheCreateInfo *>(&createInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)), | |
| reinterpret_cast<VkPipelineCache *>(&pipelineCache))); | |
| ObjectDestroy<Device, Dispatch> deleter(*this, allocator, d); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::PipelineCache, Dispatch>( | |
| result, pipelineCache, VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineCacheUnique", deleter); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroyPipelineCache(VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyPipelineCache(m_device, static_cast<VkPipelineCache>(pipelineCache), reinterpret_cast<const VkAllocationCallbacks *>(pAllocator)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroyPipelineCache(VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyPipelineCache(m_device, | |
| static_cast<VkPipelineCache>(pipelineCache), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy(VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyPipelineCache(m_device, static_cast<VkPipelineCache>(pipelineCache), reinterpret_cast<const VkAllocationCallbacks *>(pAllocator)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy(VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyPipelineCache(m_device, | |
| static_cast<VkPipelineCache>(pipelineCache), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getPipelineCacheData(VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| size_t *pDataSize, | |
| void *pData, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkGetPipelineCacheData(m_device, static_cast<VkPipelineCache>(pipelineCache), pDataSize, pData)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Uint8_tAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type | |
| Device::getPipelineCacheData(VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| std::vector<uint8_t, Uint8_tAllocator> data; | |
| size_t dataSize; | |
| Result result; | |
| do | |
| { | |
| result = static_cast<Result>(d.vkGetPipelineCacheData(m_device, static_cast<VkPipelineCache>(pipelineCache), &dataSize, nullptr)); | |
| if((result == Result::eSuccess) && dataSize) | |
| { | |
| data.resize(dataSize); | |
| result = static_cast<Result>( | |
| d.vkGetPipelineCacheData(m_device, static_cast<VkPipelineCache>(pipelineCache), &dataSize, reinterpret_cast<void *>(data.data()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(dataSize <= data.size()); | |
| if(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()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(dataSize <= data.size()); | |
| if(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); | |
| VkResult result = d.vkMergePipelineCaches( | |
| m_device, static_cast<VkPipelineCache>(dstCache), srcCaches.size(), reinterpret_cast<const VkPipelineCache *>(srcCaches.data())); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::mergePipelineCaches"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createGraphicsPipelines(VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| uint32_t createInfoCount, | |
| const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo *pCreateInfos, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| VULKAN_HPP_NAMESPACE::Pipeline *pPipelines, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkCreateGraphicsPipelines(m_device, | |
| static_cast<VkPipelineCache>(pipelineCache), | |
| createInfoCount, | |
| reinterpret_cast<const VkGraphicsPipelineCreateInfo *>(pCreateInfos), | |
| reinterpret_cast<const VkAllocationCallbacks *>(pAllocator), | |
| reinterpret_cast<VkPipeline *>(pPipelines))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename PipelineAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>> | |
| Device::createGraphicsPipelines(VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const &createInfos, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator> pipelines(createInfos.size()); | |
| VkResult 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())); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelines", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT }); | |
| return ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), pipelines); | |
| } | |
| template<typename PipelineAllocator, | |
| typename Dispatch, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, Pipeline>::value, int>::type> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>> | |
| Device::createGraphicsPipelines(VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const &createInfos, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| PipelineAllocator &pipelineAllocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator> pipelines(createInfos.size(), pipelineAllocator); | |
| VkResult 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())); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelines", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT }); | |
| return ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), pipelines); | |
| } | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<VULKAN_HPP_NAMESPACE::Pipeline> | |
| Device::createGraphicsPipeline(VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::Pipeline pipeline; | |
| VkResult 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)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipeline", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT }); | |
| return ResultValue<VULKAN_HPP_NAMESPACE::Pipeline>(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), pipeline); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch, typename PipelineAllocator> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>> | |
| Device::createGraphicsPipelinesUnique(VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const &createInfos, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator> uniquePipelines; | |
| std::vector<Pipeline> pipelines(createInfos.size()); | |
| Result result = static_cast<Result>(d.vkCreateGraphicsPipelines( | |
| m_device, | |
| static_cast<VkPipelineCache>(pipelineCache), | |
| createInfos.size(), | |
| reinterpret_cast<const VkGraphicsPipelineCreateInfo *>(createInfos.data()), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)), | |
| reinterpret_cast<VkPipeline *>(pipelines.data()))); | |
| if((result == VULKAN_HPP_NAMESPACE::Result::eSuccess) || (result == VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT)) | |
| { | |
| uniquePipelines.reserve(createInfos.size()); | |
| ObjectDestroy<Device, Dispatch> deleter(*this, allocator, d); | |
| for(size_t i = 0; i < createInfos.size(); i++) | |
| { | |
| uniquePipelines.push_back(UniqueHandle<Pipeline, Dispatch>(pipelines[i], deleter)); | |
| } | |
| } | |
| return createResultValue(result, | |
| std::move(uniquePipelines), | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelinesUnique", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT }); | |
| } | |
| template<typename Dispatch, | |
| typename PipelineAllocator, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<Pipeline, Dispatch>>::value, int>::type> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>> | |
| Device::createGraphicsPipelinesUnique(VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const &createInfos, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| PipelineAllocator &pipelineAllocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator> uniquePipelines(pipelineAllocator); | |
| std::vector<Pipeline> pipelines(createInfos.size()); | |
| Result result = static_cast<Result>(d.vkCreateGraphicsPipelines( | |
| m_device, | |
| static_cast<VkPipelineCache>(pipelineCache), | |
| createInfos.size(), | |
| reinterpret_cast<const VkGraphicsPipelineCreateInfo *>(createInfos.data()), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)), | |
| reinterpret_cast<VkPipeline *>(pipelines.data()))); | |
| if((result == VULKAN_HPP_NAMESPACE::Result::eSuccess) || (result == VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT)) | |
| { | |
| uniquePipelines.reserve(createInfos.size()); | |
| ObjectDestroy<Device, Dispatch> deleter(*this, allocator, d); | |
| for(size_t i = 0; i < createInfos.size(); i++) | |
| { | |
| uniquePipelines.push_back(UniqueHandle<Pipeline, Dispatch>(pipelines[i], deleter)); | |
| } | |
| } | |
| return createResultValue(result, | |
| std::move(uniquePipelines), | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelinesUnique", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT }); | |
| } | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<UniqueHandle<Pipeline, Dispatch>> | |
| Device::createGraphicsPipelineUnique(VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| Pipeline pipeline; | |
| Result result = static_cast<Result>(d.vkCreateGraphicsPipelines( | |
| m_device, | |
| static_cast<VkPipelineCache>(pipelineCache), | |
| 1, | |
| reinterpret_cast<const VkGraphicsPipelineCreateInfo *>(&createInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)), | |
| reinterpret_cast<VkPipeline *>(&pipeline))); | |
| ObjectDestroy<Device, Dispatch> deleter(*this, allocator, d); | |
| return createResultValue<Pipeline, Dispatch>(result, | |
| pipeline, | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelineUnique", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT }, | |
| deleter); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createComputePipelines(VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| uint32_t createInfoCount, | |
| const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo *pCreateInfos, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| VULKAN_HPP_NAMESPACE::Pipeline *pPipelines, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkCreateComputePipelines(m_device, | |
| static_cast<VkPipelineCache>(pipelineCache), | |
| createInfoCount, | |
| reinterpret_cast<const VkComputePipelineCreateInfo *>(pCreateInfos), | |
| reinterpret_cast<const VkAllocationCallbacks *>(pAllocator), | |
| reinterpret_cast<VkPipeline *>(pPipelines))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename PipelineAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>> | |
| Device::createComputePipelines(VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const &createInfos, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator> pipelines(createInfos.size()); | |
| VkResult 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())); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelines", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT }); | |
| return ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), pipelines); | |
| } | |
| template<typename PipelineAllocator, | |
| typename Dispatch, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, Pipeline>::value, int>::type> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>> | |
| Device::createComputePipelines(VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const &createInfos, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| PipelineAllocator &pipelineAllocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator> pipelines(createInfos.size(), pipelineAllocator); | |
| VkResult 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())); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelines", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT }); | |
| return ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), pipelines); | |
| } | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<VULKAN_HPP_NAMESPACE::Pipeline> | |
| Device::createComputePipeline(VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::Pipeline pipeline; | |
| VkResult 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)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipeline", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT }); | |
| return ResultValue<VULKAN_HPP_NAMESPACE::Pipeline>(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), pipeline); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch, typename PipelineAllocator> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>> | |
| Device::createComputePipelinesUnique(VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const &createInfos, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator> uniquePipelines; | |
| std::vector<Pipeline> pipelines(createInfos.size()); | |
| Result result = static_cast<Result>(d.vkCreateComputePipelines( | |
| m_device, | |
| static_cast<VkPipelineCache>(pipelineCache), | |
| createInfos.size(), | |
| reinterpret_cast<const VkComputePipelineCreateInfo *>(createInfos.data()), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)), | |
| reinterpret_cast<VkPipeline *>(pipelines.data()))); | |
| if((result == VULKAN_HPP_NAMESPACE::Result::eSuccess) || (result == VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT)) | |
| { | |
| uniquePipelines.reserve(createInfos.size()); | |
| ObjectDestroy<Device, Dispatch> deleter(*this, allocator, d); | |
| for(size_t i = 0; i < createInfos.size(); i++) | |
| { | |
| uniquePipelines.push_back(UniqueHandle<Pipeline, Dispatch>(pipelines[i], deleter)); | |
| } | |
| } | |
| return createResultValue(result, | |
| std::move(uniquePipelines), | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelinesUnique", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT }); | |
| } | |
| template<typename Dispatch, | |
| typename PipelineAllocator, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<Pipeline, Dispatch>>::value, int>::type> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>> | |
| Device::createComputePipelinesUnique(VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const &createInfos, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| PipelineAllocator &pipelineAllocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator> uniquePipelines(pipelineAllocator); | |
| std::vector<Pipeline> pipelines(createInfos.size()); | |
| Result result = static_cast<Result>(d.vkCreateComputePipelines( | |
| m_device, | |
| static_cast<VkPipelineCache>(pipelineCache), | |
| createInfos.size(), | |
| reinterpret_cast<const VkComputePipelineCreateInfo *>(createInfos.data()), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)), | |
| reinterpret_cast<VkPipeline *>(pipelines.data()))); | |
| if((result == VULKAN_HPP_NAMESPACE::Result::eSuccess) || (result == VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT)) | |
| { | |
| uniquePipelines.reserve(createInfos.size()); | |
| ObjectDestroy<Device, Dispatch> deleter(*this, allocator, d); | |
| for(size_t i = 0; i < createInfos.size(); i++) | |
| { | |
| uniquePipelines.push_back(UniqueHandle<Pipeline, Dispatch>(pipelines[i], deleter)); | |
| } | |
| } | |
| return createResultValue(result, | |
| std::move(uniquePipelines), | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelinesUnique", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT }); | |
| } | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<UniqueHandle<Pipeline, Dispatch>> | |
| Device::createComputePipelineUnique(VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| Pipeline pipeline; | |
| Result result = static_cast<Result>(d.vkCreateComputePipelines( | |
| m_device, | |
| static_cast<VkPipelineCache>(pipelineCache), | |
| 1, | |
| reinterpret_cast<const VkComputePipelineCreateInfo *>(&createInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)), | |
| reinterpret_cast<VkPipeline *>(&pipeline))); | |
| ObjectDestroy<Device, Dispatch> deleter(*this, allocator, d); | |
| return createResultValue<Pipeline, Dispatch>(result, | |
| pipeline, | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelineUnique", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT }, | |
| deleter); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroyPipeline(VULKAN_HPP_NAMESPACE::Pipeline pipeline, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyPipeline(m_device, static_cast<VkPipeline>(pipeline), reinterpret_cast<const VkAllocationCallbacks *>(pAllocator)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroyPipeline(VULKAN_HPP_NAMESPACE::Pipeline pipeline, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyPipeline(m_device, | |
| static_cast<VkPipeline>(pipeline), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy(VULKAN_HPP_NAMESPACE::Pipeline pipeline, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyPipeline(m_device, static_cast<VkPipeline>(pipeline), reinterpret_cast<const VkAllocationCallbacks *>(pAllocator)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy(VULKAN_HPP_NAMESPACE::Pipeline pipeline, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyPipeline(m_device, | |
| static_cast<VkPipeline>(pipeline), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createPipelineLayout(const VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo *pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| VULKAN_HPP_NAMESPACE::PipelineLayout *pPipelineLayout, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkCreatePipelineLayout(m_device, | |
| reinterpret_cast<const VkPipelineLayoutCreateInfo *>(pCreateInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(pAllocator), | |
| reinterpret_cast<VkPipelineLayout *>(pPipelineLayout))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::PipelineLayout>::type | |
| Device::createPipelineLayout(const VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout; | |
| VkResult 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)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineLayout"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), pipelineLayout); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineLayout, Dispatch>>::type | |
| Device::createPipelineLayoutUnique(const VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout; | |
| Result result = static_cast<Result>( | |
| d.vkCreatePipelineLayout(m_device, | |
| reinterpret_cast<const VkPipelineLayoutCreateInfo *>(&createInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)), | |
| reinterpret_cast<VkPipelineLayout *>(&pipelineLayout))); | |
| ObjectDestroy<Device, Dispatch> deleter(*this, allocator, d); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::PipelineLayout, Dispatch>( | |
| result, pipelineLayout, VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineLayoutUnique", deleter); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroyPipelineLayout(VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyPipelineLayout(m_device, static_cast<VkPipelineLayout>(pipelineLayout), reinterpret_cast<const VkAllocationCallbacks *>(pAllocator)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroyPipelineLayout(VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyPipelineLayout(m_device, | |
| static_cast<VkPipelineLayout>(pipelineLayout), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy(VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyPipelineLayout(m_device, static_cast<VkPipelineLayout>(pipelineLayout), reinterpret_cast<const VkAllocationCallbacks *>(pAllocator)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy(VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyPipelineLayout(m_device, | |
| static_cast<VkPipelineLayout>(pipelineLayout), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createSampler(const VULKAN_HPP_NAMESPACE::SamplerCreateInfo *pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| VULKAN_HPP_NAMESPACE::Sampler *pSampler, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkCreateSampler(m_device, | |
| reinterpret_cast<const VkSamplerCreateInfo *>(pCreateInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(pAllocator), | |
| reinterpret_cast<VkSampler *>(pSampler))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::Sampler>::type Device::createSampler( | |
| const VULKAN_HPP_NAMESPACE::SamplerCreateInfo &createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::Sampler sampler; | |
| VkResult 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)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::createSampler"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), sampler); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Sampler, Dispatch>>::type Device::createSamplerUnique( | |
| const VULKAN_HPP_NAMESPACE::SamplerCreateInfo &createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::Sampler sampler; | |
| Result result = static_cast<Result>( | |
| d.vkCreateSampler(m_device, | |
| reinterpret_cast<const VkSamplerCreateInfo *>(&createInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)), | |
| reinterpret_cast<VkSampler *>(&sampler))); | |
| ObjectDestroy<Device, Dispatch> deleter(*this, allocator, d); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::Sampler, Dispatch>(result, sampler, VULKAN_HPP_NAMESPACE_STRING "::Device::createSamplerUnique", deleter); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroySampler(VULKAN_HPP_NAMESPACE::Sampler sampler, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroySampler(m_device, static_cast<VkSampler>(sampler), reinterpret_cast<const VkAllocationCallbacks *>(pAllocator)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroySampler(VULKAN_HPP_NAMESPACE::Sampler sampler, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroySampler(m_device, | |
| static_cast<VkSampler>(sampler), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy(VULKAN_HPP_NAMESPACE::Sampler sampler, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroySampler(m_device, static_cast<VkSampler>(sampler), reinterpret_cast<const VkAllocationCallbacks *>(pAllocator)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy(VULKAN_HPP_NAMESPACE::Sampler sampler, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroySampler(m_device, | |
| static_cast<VkSampler>(sampler), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createDescriptorSetLayout(const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo *pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| VULKAN_HPP_NAMESPACE::DescriptorSetLayout *pSetLayout, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkCreateDescriptorSetLayout(m_device, | |
| reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>(pCreateInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(pAllocator), | |
| reinterpret_cast<VkDescriptorSetLayout *>(pSetLayout))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::DescriptorSetLayout>::type | |
| Device::createDescriptorSetLayout(const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::DescriptorSetLayout setLayout; | |
| VkResult 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)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorSetLayout"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), setLayout); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSetLayout, Dispatch>>::type | |
| Device::createDescriptorSetLayoutUnique(const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::DescriptorSetLayout setLayout; | |
| Result result = static_cast<Result>(d.vkCreateDescriptorSetLayout( | |
| m_device, | |
| reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>(&createInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)), | |
| reinterpret_cast<VkDescriptorSetLayout *>(&setLayout))); | |
| ObjectDestroy<Device, Dispatch> deleter(*this, allocator, d); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::DescriptorSetLayout, Dispatch>( | |
| result, setLayout, VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorSetLayoutUnique", deleter); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroyDescriptorSetLayout(VULKAN_HPP_NAMESPACE::DescriptorSetLayout descriptorSetLayout, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyDescriptorSetLayout( | |
| m_device, static_cast<VkDescriptorSetLayout>(descriptorSetLayout), reinterpret_cast<const VkAllocationCallbacks *>(pAllocator)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroyDescriptorSetLayout(VULKAN_HPP_NAMESPACE::DescriptorSetLayout descriptorSetLayout, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyDescriptorSetLayout( | |
| m_device, | |
| static_cast<VkDescriptorSetLayout>(descriptorSetLayout), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy(VULKAN_HPP_NAMESPACE::DescriptorSetLayout descriptorSetLayout, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyDescriptorSetLayout( | |
| m_device, static_cast<VkDescriptorSetLayout>(descriptorSetLayout), reinterpret_cast<const VkAllocationCallbacks *>(pAllocator)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy(VULKAN_HPP_NAMESPACE::DescriptorSetLayout descriptorSetLayout, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyDescriptorSetLayout( | |
| m_device, | |
| static_cast<VkDescriptorSetLayout>(descriptorSetLayout), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createDescriptorPool(const VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo *pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| VULKAN_HPP_NAMESPACE::DescriptorPool *pDescriptorPool, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkCreateDescriptorPool(m_device, | |
| reinterpret_cast<const VkDescriptorPoolCreateInfo *>(pCreateInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(pAllocator), | |
| reinterpret_cast<VkDescriptorPool *>(pDescriptorPool))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::DescriptorPool>::type | |
| Device::createDescriptorPool(const VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool; | |
| VkResult 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)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorPool"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), descriptorPool); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorPool, Dispatch>>::type | |
| Device::createDescriptorPoolUnique(const VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool; | |
| Result result = static_cast<Result>( | |
| d.vkCreateDescriptorPool(m_device, | |
| reinterpret_cast<const VkDescriptorPoolCreateInfo *>(&createInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)), | |
| reinterpret_cast<VkDescriptorPool *>(&descriptorPool))); | |
| ObjectDestroy<Device, Dispatch> deleter(*this, allocator, d); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::DescriptorPool, Dispatch>( | |
| result, descriptorPool, VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorPoolUnique", deleter); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroyDescriptorPool(VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyDescriptorPool(m_device, static_cast<VkDescriptorPool>(descriptorPool), reinterpret_cast<const VkAllocationCallbacks *>(pAllocator)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroyDescriptorPool(VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyDescriptorPool(m_device, | |
| static_cast<VkDescriptorPool>(descriptorPool), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy(VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyDescriptorPool(m_device, static_cast<VkDescriptorPool>(descriptorPool), reinterpret_cast<const VkAllocationCallbacks *>(pAllocator)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy(VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyDescriptorPool(m_device, | |
| static_cast<VkDescriptorPool>(descriptorPool), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE Result Device::resetDescriptorPool(VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, | |
| VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlags flags, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>( | |
| d.vkResetDescriptorPool(m_device, static_cast<VkDescriptorPool>(descriptorPool), static_cast<VkDescriptorPoolResetFlags>(flags))); | |
| } | |
| #else | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::resetDescriptorPool(VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, | |
| VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlags flags, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkResetDescriptorPool(m_device, static_cast<VkDescriptorPool>(descriptorPool), static_cast<VkDescriptorPoolResetFlags>(flags)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::allocateDescriptorSets(const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo *pAllocateInfo, | |
| VULKAN_HPP_NAMESPACE::DescriptorSet *pDescriptorSets, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkAllocateDescriptorSets( | |
| m_device, reinterpret_cast<const VkDescriptorSetAllocateInfo *>(pAllocateInfo), reinterpret_cast<VkDescriptorSet *>(pDescriptorSets))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename DescriptorSetAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DescriptorSet, DescriptorSetAllocator>>::type | |
| Device::allocateDescriptorSets(const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo &allocateInfo, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| std::vector<VULKAN_HPP_NAMESPACE::DescriptorSet, DescriptorSetAllocator> descriptorSets(allocateInfo.descriptorSetCount); | |
| VkResult result = d.vkAllocateDescriptorSets( | |
| m_device, reinterpret_cast<const VkDescriptorSetAllocateInfo *>(&allocateInfo), reinterpret_cast<VkDescriptorSet *>(descriptorSets.data())); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSets"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), descriptorSets); | |
| } | |
| 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 VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DescriptorSet, DescriptorSetAllocator>>::type | |
| Device::allocateDescriptorSets(const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo &allocateInfo, | |
| DescriptorSetAllocator &descriptorSetAllocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| std::vector<VULKAN_HPP_NAMESPACE::DescriptorSet, DescriptorSetAllocator> descriptorSets(allocateInfo.descriptorSetCount, descriptorSetAllocator); | |
| VkResult result = d.vkAllocateDescriptorSets( | |
| m_device, reinterpret_cast<const VkDescriptorSetAllocateInfo *>(&allocateInfo), reinterpret_cast<VkDescriptorSet *>(descriptorSets.data())); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSets"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), descriptorSets); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch, typename DescriptorSetAllocator> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<DescriptorSet, Dispatch>, DescriptorSetAllocator>>::type | |
| Device::allocateDescriptorSetsUnique(const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo &allocateInfo, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| std::vector<UniqueHandle<DescriptorSet, Dispatch>, DescriptorSetAllocator> uniqueDescriptorSets; | |
| std::vector<DescriptorSet> descriptorSets(allocateInfo.descriptorSetCount); | |
| Result result = static_cast<Result>(d.vkAllocateDescriptorSets( | |
| m_device, reinterpret_cast<const VkDescriptorSetAllocateInfo *>(&allocateInfo), reinterpret_cast<VkDescriptorSet *>(descriptorSets.data()))); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| uniqueDescriptorSets.reserve(allocateInfo.descriptorSetCount); | |
| PoolFree<Device, DescriptorPool, Dispatch> deleter(*this, allocateInfo.descriptorPool, d); | |
| for(size_t i = 0; i < allocateInfo.descriptorSetCount; i++) | |
| { | |
| uniqueDescriptorSets.push_back(UniqueHandle<DescriptorSet, Dispatch>(descriptorSets[i], deleter)); | |
| } | |
| } | |
| return createResultValue(result, std::move(uniqueDescriptorSets), VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSetsUnique"); | |
| } | |
| template<typename Dispatch, | |
| typename DescriptorSetAllocator, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<DescriptorSet, Dispatch>>::value, int>::type> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<DescriptorSet, Dispatch>, DescriptorSetAllocator>>::type | |
| Device::allocateDescriptorSetsUnique(const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo &allocateInfo, | |
| DescriptorSetAllocator &descriptorSetAllocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| std::vector<UniqueHandle<DescriptorSet, Dispatch>, DescriptorSetAllocator> uniqueDescriptorSets(descriptorSetAllocator); | |
| std::vector<DescriptorSet> descriptorSets(allocateInfo.descriptorSetCount); | |
| Result result = static_cast<Result>(d.vkAllocateDescriptorSets( | |
| m_device, reinterpret_cast<const VkDescriptorSetAllocateInfo *>(&allocateInfo), reinterpret_cast<VkDescriptorSet *>(descriptorSets.data()))); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| uniqueDescriptorSets.reserve(allocateInfo.descriptorSetCount); | |
| PoolFree<Device, DescriptorPool, Dispatch> deleter(*this, allocateInfo.descriptorPool, d); | |
| for(size_t i = 0; i < allocateInfo.descriptorSetCount; i++) | |
| { | |
| uniqueDescriptorSets.push_back(UniqueHandle<DescriptorSet, Dispatch>(descriptorSets[i], deleter)); | |
| } | |
| } | |
| return createResultValue(result, std::move(uniqueDescriptorSets), VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSetsUnique"); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE Result Device::freeDescriptorSets(VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, | |
| uint32_t descriptorSetCount, | |
| const VULKAN_HPP_NAMESPACE::DescriptorSet *pDescriptorSets, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkFreeDescriptorSets( | |
| m_device, static_cast<VkDescriptorPool>(descriptorPool), descriptorSetCount, reinterpret_cast<const VkDescriptorSet *>(pDescriptorSets))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::freeDescriptorSets(VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const &descriptorSets, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkFreeDescriptorSets( | |
| m_device, static_cast<VkDescriptorPool>(descriptorPool), descriptorSets.size(), reinterpret_cast<const VkDescriptorSet *>(descriptorSets.data())); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE Result(Device::free)(VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, | |
| uint32_t descriptorSetCount, | |
| const VULKAN_HPP_NAMESPACE::DescriptorSet *pDescriptorSets, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkFreeDescriptorSets( | |
| m_device, static_cast<VkDescriptorPool>(descriptorPool), descriptorSetCount, reinterpret_cast<const VkDescriptorSet *>(pDescriptorSets))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void(Device::free)(VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const &descriptorSets, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkFreeDescriptorSets( | |
| m_device, static_cast<VkDescriptorPool>(descriptorPool), descriptorSets.size(), reinterpret_cast<const VkDescriptorSet *>(descriptorSets.data())); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::updateDescriptorSets(uint32_t descriptorWriteCount, | |
| const VULKAN_HPP_NAMESPACE::WriteDescriptorSet *pDescriptorWrites, | |
| uint32_t descriptorCopyCount, | |
| const VULKAN_HPP_NAMESPACE::CopyDescriptorSet *pDescriptorCopies, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkUpdateDescriptorSets(m_device, | |
| descriptorWriteCount, | |
| reinterpret_cast<const VkWriteDescriptorSet *>(pDescriptorWrites), | |
| descriptorCopyCount, | |
| reinterpret_cast<const VkCopyDescriptorSet *>(pDescriptorCopies)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::updateDescriptorSets(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 VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::Framebuffer>::type | |
| Device::createFramebuffer(const VULKAN_HPP_NAMESPACE::FramebufferCreateInfo &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::Framebuffer framebuffer; | |
| VkResult 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)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::createFramebuffer"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), framebuffer); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Framebuffer, Dispatch>>::type | |
| Device::createFramebufferUnique(const VULKAN_HPP_NAMESPACE::FramebufferCreateInfo &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::Framebuffer framebuffer; | |
| Result result = static_cast<Result>( | |
| d.vkCreateFramebuffer(m_device, | |
| reinterpret_cast<const VkFramebufferCreateInfo *>(&createInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)), | |
| reinterpret_cast<VkFramebuffer *>(&framebuffer))); | |
| ObjectDestroy<Device, Dispatch> deleter(*this, allocator, d); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::Framebuffer, Dispatch>( | |
| result, framebuffer, VULKAN_HPP_NAMESPACE_STRING "::Device::createFramebufferUnique", deleter); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroyFramebuffer(VULKAN_HPP_NAMESPACE::Framebuffer framebuffer, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyFramebuffer(m_device, static_cast<VkFramebuffer>(framebuffer), reinterpret_cast<const VkAllocationCallbacks *>(pAllocator)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroyFramebuffer(VULKAN_HPP_NAMESPACE::Framebuffer framebuffer, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyFramebuffer(m_device, | |
| static_cast<VkFramebuffer>(framebuffer), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy(VULKAN_HPP_NAMESPACE::Framebuffer framebuffer, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyFramebuffer(m_device, static_cast<VkFramebuffer>(framebuffer), reinterpret_cast<const VkAllocationCallbacks *>(pAllocator)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy(VULKAN_HPP_NAMESPACE::Framebuffer framebuffer, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyFramebuffer(m_device, | |
| static_cast<VkFramebuffer>(framebuffer), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createRenderPass(const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo *pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| VULKAN_HPP_NAMESPACE::RenderPass *pRenderPass, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkCreateRenderPass(m_device, | |
| reinterpret_cast<const VkRenderPassCreateInfo *>(pCreateInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(pAllocator), | |
| reinterpret_cast<VkRenderPass *>(pRenderPass))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::RenderPass>::type | |
| Device::createRenderPass(const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::RenderPass renderPass; | |
| VkResult 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)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPass"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), renderPass); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>>::type | |
| Device::createRenderPassUnique(const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::RenderPass renderPass; | |
| Result result = static_cast<Result>( | |
| d.vkCreateRenderPass(m_device, | |
| reinterpret_cast<const VkRenderPassCreateInfo *>(&createInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)), | |
| reinterpret_cast<VkRenderPass *>(&renderPass))); | |
| ObjectDestroy<Device, Dispatch> deleter(*this, allocator, d); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>( | |
| result, renderPass, VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPassUnique", deleter); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroyRenderPass(VULKAN_HPP_NAMESPACE::RenderPass renderPass, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyRenderPass(m_device, static_cast<VkRenderPass>(renderPass), reinterpret_cast<const VkAllocationCallbacks *>(pAllocator)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroyRenderPass(VULKAN_HPP_NAMESPACE::RenderPass renderPass, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyRenderPass(m_device, | |
| static_cast<VkRenderPass>(renderPass), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy(VULKAN_HPP_NAMESPACE::RenderPass renderPass, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyRenderPass(m_device, static_cast<VkRenderPass>(renderPass), reinterpret_cast<const VkAllocationCallbacks *>(pAllocator)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy(VULKAN_HPP_NAMESPACE::RenderPass renderPass, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyRenderPass(m_device, | |
| static_cast<VkRenderPass>(renderPass), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::getRenderAreaGranularity(VULKAN_HPP_NAMESPACE::RenderPass renderPass, | |
| VULKAN_HPP_NAMESPACE::Extent2D *pGranularity, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkGetRenderAreaGranularity(m_device, static_cast<VkRenderPass>(renderPass), reinterpret_cast<VkExtent2D *>(pGranularity)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Extent2D Device::getRenderAreaGranularity(VULKAN_HPP_NAMESPACE::RenderPass renderPass, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::Extent2D granularity; | |
| d.vkGetRenderAreaGranularity(m_device, static_cast<VkRenderPass>(renderPass), reinterpret_cast<VkExtent2D *>(&granularity)); | |
| return granularity; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createCommandPool(const VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo *pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| VULKAN_HPP_NAMESPACE::CommandPool *pCommandPool, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkCreateCommandPool(m_device, | |
| reinterpret_cast<const VkCommandPoolCreateInfo *>(pCreateInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(pAllocator), | |
| reinterpret_cast<VkCommandPool *>(pCommandPool))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::CommandPool>::type | |
| Device::createCommandPool(const VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::CommandPool commandPool; | |
| VkResult 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)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::createCommandPool"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), commandPool); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandPool, Dispatch>>::type | |
| Device::createCommandPoolUnique(const VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::CommandPool commandPool; | |
| Result result = static_cast<Result>( | |
| d.vkCreateCommandPool(m_device, | |
| reinterpret_cast<const VkCommandPoolCreateInfo *>(&createInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)), | |
| reinterpret_cast<VkCommandPool *>(&commandPool))); | |
| ObjectDestroy<Device, Dispatch> deleter(*this, allocator, d); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::CommandPool, Dispatch>( | |
| result, commandPool, VULKAN_HPP_NAMESPACE_STRING "::Device::createCommandPoolUnique", deleter); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroyCommandPool(VULKAN_HPP_NAMESPACE::CommandPool commandPool, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyCommandPool(m_device, static_cast<VkCommandPool>(commandPool), reinterpret_cast<const VkAllocationCallbacks *>(pAllocator)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroyCommandPool(VULKAN_HPP_NAMESPACE::CommandPool commandPool, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyCommandPool(m_device, | |
| static_cast<VkCommandPool>(commandPool), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy(VULKAN_HPP_NAMESPACE::CommandPool commandPool, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyCommandPool(m_device, static_cast<VkCommandPool>(commandPool), reinterpret_cast<const VkAllocationCallbacks *>(pAllocator)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy(VULKAN_HPP_NAMESPACE::CommandPool commandPool, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyCommandPool(m_device, | |
| static_cast<VkCommandPool>(commandPool), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::resetCommandPool(VULKAN_HPP_NAMESPACE::CommandPool commandPool, | |
| VULKAN_HPP_NAMESPACE::CommandPoolResetFlags flags, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkResetCommandPool(m_device, static_cast<VkCommandPool>(commandPool), static_cast<VkCommandPoolResetFlags>(flags))); | |
| } | |
| #else | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| Device::resetCommandPool(VULKAN_HPP_NAMESPACE::CommandPool commandPool, VULKAN_HPP_NAMESPACE::CommandPoolResetFlags flags, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VkResult result = d.vkResetCommandPool(m_device, static_cast<VkCommandPool>(commandPool), static_cast<VkCommandPoolResetFlags>(flags)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::resetCommandPool"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::allocateCommandBuffers(const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo *pAllocateInfo, | |
| VULKAN_HPP_NAMESPACE::CommandBuffer *pCommandBuffers, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkAllocateCommandBuffers( | |
| m_device, reinterpret_cast<const VkCommandBufferAllocateInfo *>(pAllocateInfo), reinterpret_cast<VkCommandBuffer *>(pCommandBuffers))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename CommandBufferAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CommandBuffer, CommandBufferAllocator>>::type | |
| Device::allocateCommandBuffers(const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo &allocateInfo, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| std::vector<VULKAN_HPP_NAMESPACE::CommandBuffer, CommandBufferAllocator> commandBuffers(allocateInfo.commandBufferCount); | |
| VkResult result = d.vkAllocateCommandBuffers( | |
| m_device, reinterpret_cast<const VkCommandBufferAllocateInfo *>(&allocateInfo), reinterpret_cast<VkCommandBuffer *>(commandBuffers.data())); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffers"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), commandBuffers); | |
| } | |
| 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 VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CommandBuffer, CommandBufferAllocator>>::type | |
| Device::allocateCommandBuffers(const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo &allocateInfo, | |
| CommandBufferAllocator &commandBufferAllocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| std::vector<VULKAN_HPP_NAMESPACE::CommandBuffer, CommandBufferAllocator> commandBuffers(allocateInfo.commandBufferCount, commandBufferAllocator); | |
| VkResult result = d.vkAllocateCommandBuffers( | |
| m_device, reinterpret_cast<const VkCommandBufferAllocateInfo *>(&allocateInfo), reinterpret_cast<VkCommandBuffer *>(commandBuffers.data())); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffers"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), commandBuffers); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch, typename CommandBufferAllocator> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<CommandBuffer, Dispatch>, CommandBufferAllocator>>::type | |
| Device::allocateCommandBuffersUnique(const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo &allocateInfo, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| std::vector<UniqueHandle<CommandBuffer, Dispatch>, CommandBufferAllocator> uniqueCommandBuffers; | |
| std::vector<CommandBuffer> commandBuffers(allocateInfo.commandBufferCount); | |
| Result result = static_cast<Result>(d.vkAllocateCommandBuffers( | |
| m_device, reinterpret_cast<const VkCommandBufferAllocateInfo *>(&allocateInfo), reinterpret_cast<VkCommandBuffer *>(commandBuffers.data()))); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| uniqueCommandBuffers.reserve(allocateInfo.commandBufferCount); | |
| PoolFree<Device, CommandPool, Dispatch> deleter(*this, allocateInfo.commandPool, d); | |
| for(size_t i = 0; i < allocateInfo.commandBufferCount; i++) | |
| { | |
| uniqueCommandBuffers.push_back(UniqueHandle<CommandBuffer, Dispatch>(commandBuffers[i], deleter)); | |
| } | |
| } | |
| return createResultValue(result, std::move(uniqueCommandBuffers), VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffersUnique"); | |
| } | |
| template<typename Dispatch, | |
| typename CommandBufferAllocator, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<CommandBuffer, Dispatch>>::value, int>::type> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<CommandBuffer, Dispatch>, CommandBufferAllocator>>::type | |
| Device::allocateCommandBuffersUnique(const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo &allocateInfo, | |
| CommandBufferAllocator &commandBufferAllocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| std::vector<UniqueHandle<CommandBuffer, Dispatch>, CommandBufferAllocator> uniqueCommandBuffers(commandBufferAllocator); | |
| std::vector<CommandBuffer> commandBuffers(allocateInfo.commandBufferCount); | |
| Result result = static_cast<Result>(d.vkAllocateCommandBuffers( | |
| m_device, reinterpret_cast<const VkCommandBufferAllocateInfo *>(&allocateInfo), reinterpret_cast<VkCommandBuffer *>(commandBuffers.data()))); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| uniqueCommandBuffers.reserve(allocateInfo.commandBufferCount); | |
| PoolFree<Device, CommandPool, Dispatch> deleter(*this, allocateInfo.commandPool, d); | |
| for(size_t i = 0; i < allocateInfo.commandBufferCount; i++) | |
| { | |
| uniqueCommandBuffers.push_back(UniqueHandle<CommandBuffer, Dispatch>(commandBuffers[i], deleter)); | |
| } | |
| } | |
| return createResultValue(result, std::move(uniqueCommandBuffers), VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffersUnique"); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::freeCommandBuffers(VULKAN_HPP_NAMESPACE::CommandPool commandPool, | |
| uint32_t commandBufferCount, | |
| const VULKAN_HPP_NAMESPACE::CommandBuffer *pCommandBuffers, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkFreeCommandBuffers( | |
| m_device, static_cast<VkCommandPool>(commandPool), commandBufferCount, reinterpret_cast<const VkCommandBuffer *>(pCommandBuffers)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::freeCommandBuffers(VULKAN_HPP_NAMESPACE::CommandPool commandPool, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const &commandBuffers, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkFreeCommandBuffers( | |
| m_device, static_cast<VkCommandPool>(commandPool), commandBuffers.size(), reinterpret_cast<const VkCommandBuffer *>(commandBuffers.data())); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void(Device::free)(VULKAN_HPP_NAMESPACE::CommandPool commandPool, | |
| uint32_t commandBufferCount, | |
| const VULKAN_HPP_NAMESPACE::CommandBuffer *pCommandBuffers, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkFreeCommandBuffers( | |
| m_device, static_cast<VkCommandPool>(commandPool), commandBufferCount, reinterpret_cast<const VkCommandBuffer *>(pCommandBuffers)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void(Device::free)(VULKAN_HPP_NAMESPACE::CommandPool commandPool, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const &commandBuffers, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkFreeCommandBuffers( | |
| m_device, static_cast<VkCommandPool>(commandPool), commandBuffers.size(), reinterpret_cast<const VkCommandBuffer *>(commandBuffers.data())); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result CommandBuffer::begin(const VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo *pBeginInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkBeginCommandBuffer(m_commandBuffer, reinterpret_cast<const VkCommandBufferBeginInfo *>(pBeginInfo))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| CommandBuffer::begin(const VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo &beginInfo, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VkResult result = d.vkBeginCommandBuffer(m_commandBuffer, reinterpret_cast<const VkCommandBufferBeginInfo *>(&beginInfo)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::begin"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result 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); | |
| VkResult result = d.vkEndCommandBuffer(m_commandBuffer); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::end"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result 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); | |
| VkResult result = d.vkResetCommandBuffer(m_commandBuffer, static_cast<VkCommandBufferResetFlags>(flags)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::reset"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::bindPipeline(VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, | |
| VULKAN_HPP_NAMESPACE::Pipeline pipeline, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdBindPipeline(m_commandBuffer, static_cast<VkPipelineBindPoint>(pipelineBindPoint), static_cast<VkPipeline>(pipeline)); | |
| } | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setViewport(uint32_t firstViewport, | |
| uint32_t viewportCount, | |
| const VULKAN_HPP_NAMESPACE::Viewport *pViewports, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdSetViewport(m_commandBuffer, firstViewport, viewportCount, reinterpret_cast<const VkViewport *>(pViewports)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setViewport(uint32_t firstViewport, | |
| 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 ®ions, | |
| 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 ®ions, | |
| 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 ®ions, | |
| 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 ®ions, | |
| 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 ®ions, | |
| 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 DataType, typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::updateBuffer(VULKAN_HPP_NAMESPACE::Buffer dstBuffer, | |
| VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, | |
| ArrayProxy<const DataType> 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(DataType), | |
| reinterpret_cast<const void *>(data.data())); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::fillBuffer(VULKAN_HPP_NAMESPACE::Buffer dstBuffer, | |
| VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, | |
| VULKAN_HPP_NAMESPACE::DeviceSize size, | |
| uint32_t data, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdFillBuffer(m_commandBuffer, static_cast<VkBuffer>(dstBuffer), static_cast<VkDeviceSize>(dstOffset), static_cast<VkDeviceSize>(size), data); | |
| } | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::clearColorImage(VULKAN_HPP_NAMESPACE::Image image, | |
| VULKAN_HPP_NAMESPACE::ImageLayout imageLayout, | |
| const VULKAN_HPP_NAMESPACE::ClearColorValue *pColor, | |
| uint32_t rangeCount, | |
| const VULKAN_HPP_NAMESPACE::ImageSubresourceRange *pRanges, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdClearColorImage(m_commandBuffer, | |
| static_cast<VkImage>(image), | |
| static_cast<VkImageLayout>(imageLayout), | |
| reinterpret_cast<const VkClearColorValue *>(pColor), | |
| rangeCount, | |
| reinterpret_cast<const VkImageSubresourceRange *>(pRanges)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::clearColorImage(VULKAN_HPP_NAMESPACE::Image image, | |
| VULKAN_HPP_NAMESPACE::ImageLayout imageLayout, | |
| const VULKAN_HPP_NAMESPACE::ClearColorValue &color, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceRange> const &ranges, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdClearColorImage(m_commandBuffer, | |
| static_cast<VkImage>(image), | |
| static_cast<VkImageLayout>(imageLayout), | |
| reinterpret_cast<const VkClearColorValue *>(&color), | |
| ranges.size(), | |
| reinterpret_cast<const VkImageSubresourceRange *>(ranges.data())); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::clearDepthStencilImage(VULKAN_HPP_NAMESPACE::Image image, | |
| VULKAN_HPP_NAMESPACE::ImageLayout imageLayout, | |
| const VULKAN_HPP_NAMESPACE::ClearDepthStencilValue *pDepthStencil, | |
| uint32_t rangeCount, | |
| const VULKAN_HPP_NAMESPACE::ImageSubresourceRange *pRanges, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdClearDepthStencilImage(m_commandBuffer, | |
| static_cast<VkImage>(image), | |
| static_cast<VkImageLayout>(imageLayout), | |
| reinterpret_cast<const VkClearDepthStencilValue *>(pDepthStencil), | |
| rangeCount, | |
| reinterpret_cast<const VkImageSubresourceRange *>(pRanges)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::clearDepthStencilImage(VULKAN_HPP_NAMESPACE::Image image, | |
| VULKAN_HPP_NAMESPACE::ImageLayout imageLayout, | |
| const VULKAN_HPP_NAMESPACE::ClearDepthStencilValue &depthStencil, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceRange> const &ranges, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdClearDepthStencilImage(m_commandBuffer, | |
| static_cast<VkImage>(image), | |
| static_cast<VkImageLayout>(imageLayout), | |
| reinterpret_cast<const VkClearDepthStencilValue *>(&depthStencil), | |
| ranges.size(), | |
| reinterpret_cast<const VkImageSubresourceRange *>(ranges.data())); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::clearAttachments(uint32_t attachmentCount, | |
| const VULKAN_HPP_NAMESPACE::ClearAttachment *pAttachments, | |
| uint32_t rectCount, | |
| const VULKAN_HPP_NAMESPACE::ClearRect *pRects, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdClearAttachments(m_commandBuffer, | |
| attachmentCount, | |
| reinterpret_cast<const VkClearAttachment *>(pAttachments), | |
| rectCount, | |
| reinterpret_cast<const VkClearRect *>(pRects)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::clearAttachments(ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearAttachment> const &attachments, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearRect> const &rects, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdClearAttachments(m_commandBuffer, | |
| attachments.size(), | |
| reinterpret_cast<const VkClearAttachment *>(attachments.data()), | |
| rects.size(), | |
| reinterpret_cast<const VkClearRect *>(rects.data())); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::resolveImage(VULKAN_HPP_NAMESPACE::Image srcImage, | |
| VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, | |
| VULKAN_HPP_NAMESPACE::Image dstImage, | |
| VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, | |
| uint32_t regionCount, | |
| const VULKAN_HPP_NAMESPACE::ImageResolve *pRegions, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdResolveImage(m_commandBuffer, | |
| static_cast<VkImage>(srcImage), | |
| static_cast<VkImageLayout>(srcImageLayout), | |
| static_cast<VkImage>(dstImage), | |
| static_cast<VkImageLayout>(dstImageLayout), | |
| regionCount, | |
| reinterpret_cast<const VkImageResolve *>(pRegions)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::resolveImage(VULKAN_HPP_NAMESPACE::Image srcImage, | |
| VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, | |
| VULKAN_HPP_NAMESPACE::Image dstImage, | |
| VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageResolve> const ®ions, | |
| 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 ValuesType, typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::pushConstants(VULKAN_HPP_NAMESPACE::PipelineLayout layout, | |
| VULKAN_HPP_NAMESPACE::ShaderStageFlags stageFlags, | |
| uint32_t offset, | |
| ArrayProxy<const ValuesType> 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(ValuesType), | |
| reinterpret_cast<const void *>(values.data())); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass(const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo *pRenderPassBegin, | |
| VULKAN_HPP_NAMESPACE::SubpassContents contents, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdBeginRenderPass(m_commandBuffer, reinterpret_cast<const VkRenderPassBeginInfo *>(pRenderPassBegin), static_cast<VkSubpassContents>(contents)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass(const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo &renderPassBegin, | |
| VULKAN_HPP_NAMESPACE::SubpassContents contents, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| 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_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<uint32_t>::type enumerateInstanceVersion(Dispatch const &d) | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| uint32_t apiVersion; | |
| VkResult result = d.vkEnumerateInstanceVersion(&apiVersion); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::enumerateInstanceVersion"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), apiVersion); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::bindBufferMemory2(uint32_t bindInfoCount, | |
| const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo *pBindInfos, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkBindBufferMemory2(m_device, bindInfoCount, reinterpret_cast<const VkBindBufferMemoryInfo *>(pBindInfos))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| Device::bindBufferMemory2(ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const &bindInfos, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VkResult result = d.vkBindBufferMemory2(m_device, bindInfos.size(), reinterpret_cast<const VkBindBufferMemoryInfo *>(bindInfos.data())); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::bindBufferMemory2"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::bindImageMemory2(uint32_t bindInfoCount, | |
| const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo *pBindInfos, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkBindImageMemory2(m_device, bindInfoCount, reinterpret_cast<const VkBindImageMemoryInfo *>(pBindInfos))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| Device::bindImageMemory2(ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const &bindInfos, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VkResult result = d.vkBindImageMemory2(m_device, bindInfos.size(), reinterpret_cast<const VkBindImageMemoryInfo *>(bindInfos.data())); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::bindImageMemory2"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::getGroupPeerMemoryFeatures(uint32_t heapIndex, | |
| uint32_t localDeviceIndex, | |
| uint32_t remoteDeviceIndex, | |
| VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags *pPeerMemoryFeatures, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkGetDeviceGroupPeerMemoryFeatures( | |
| m_device, heapIndex, localDeviceIndex, remoteDeviceIndex, reinterpret_cast<VkPeerMemoryFeatureFlags *>(pPeerMemoryFeatures)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags Device::getGroupPeerMemoryFeatures( | |
| uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| 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()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(physicalDeviceGroupCount <= physicalDeviceGroupProperties.size()); | |
| if(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()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(physicalDeviceGroupCount <= physicalDeviceGroupProperties.size()); | |
| if(physicalDeviceGroupCount < physicalDeviceGroupProperties.size()) | |
| { | |
| physicalDeviceGroupProperties.resize(physicalDeviceGroupCount); | |
| } | |
| } | |
| return createResultValue(result, physicalDeviceGroupProperties, VULKAN_HPP_NAMESPACE_STRING "::Instance::enumeratePhysicalDeviceGroups"); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::getImageMemoryRequirements2(const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 *pInfo, | |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 *pMemoryRequirements, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkGetImageMemoryRequirements2( | |
| m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>(pInfo), reinterpret_cast<VkMemoryRequirements2 *>(pMemoryRequirements)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2 | |
| Device::getImageMemoryRequirements2(const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 &info, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements; | |
| d.vkGetImageMemoryRequirements2( | |
| m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>(&info), reinterpret_cast<VkMemoryRequirements2 *>(&memoryRequirements)); | |
| return memoryRequirements; | |
| } | |
| template<typename X, typename Y, typename... Z, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> | |
| Device::getImageMemoryRequirements2(const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 &info, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| StructureChain<X, Y, Z...> structureChain; | |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 &memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>(); | |
| d.vkGetImageMemoryRequirements2( | |
| m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>(&info), reinterpret_cast<VkMemoryRequirements2 *>(&memoryRequirements)); | |
| return structureChain; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::getBufferMemoryRequirements2(const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 *pInfo, | |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 *pMemoryRequirements, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkGetBufferMemoryRequirements2( | |
| m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>(pInfo), reinterpret_cast<VkMemoryRequirements2 *>(pMemoryRequirements)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2 | |
| Device::getBufferMemoryRequirements2(const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 &info, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements; | |
| d.vkGetBufferMemoryRequirements2( | |
| m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>(&info), reinterpret_cast<VkMemoryRequirements2 *>(&memoryRequirements)); | |
| return memoryRequirements; | |
| } | |
| template<typename X, typename Y, typename... Z, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> | |
| Device::getBufferMemoryRequirements2(const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 &info, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| StructureChain<X, Y, Z...> structureChain; | |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 &memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>(); | |
| d.vkGetBufferMemoryRequirements2( | |
| m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>(&info), reinterpret_cast<VkMemoryRequirements2 *>(&memoryRequirements)); | |
| return structureChain; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirements2(const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 *pInfo, | |
| uint32_t *pSparseMemoryRequirementCount, | |
| VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 *pSparseMemoryRequirements, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkGetImageSparseMemoryRequirements2(m_device, | |
| reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>(pInfo), | |
| pSparseMemoryRequirementCount, | |
| reinterpret_cast<VkSparseImageMemoryRequirements2 *>(pSparseMemoryRequirements)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename SparseImageMemoryRequirements2Allocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> | |
| Device::getImageSparseMemoryRequirements2(const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 &info, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> sparseMemoryRequirements; | |
| uint32_t sparseMemoryRequirementCount; | |
| d.vkGetImageSparseMemoryRequirements2( | |
| m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>(&info), &sparseMemoryRequirementCount, nullptr); | |
| sparseMemoryRequirements.resize(sparseMemoryRequirementCount); | |
| d.vkGetImageSparseMemoryRequirements2(m_device, | |
| reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>(&info), | |
| &sparseMemoryRequirementCount, | |
| reinterpret_cast<VkSparseImageMemoryRequirements2 *>(sparseMemoryRequirements.data())); | |
| VULKAN_HPP_ASSERT(sparseMemoryRequirementCount <= sparseMemoryRequirements.size()); | |
| return sparseMemoryRequirements; | |
| } | |
| template<typename SparseImageMemoryRequirements2Allocator, | |
| typename Dispatch, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, SparseImageMemoryRequirements2>::value, int>::type> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> | |
| Device::getImageSparseMemoryRequirements2(const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 &info, | |
| SparseImageMemoryRequirements2Allocator &sparseImageMemoryRequirements2Allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> sparseMemoryRequirements(sparseImageMemoryRequirements2Allocator); | |
| uint32_t sparseMemoryRequirementCount; | |
| d.vkGetImageSparseMemoryRequirements2( | |
| m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>(&info), &sparseMemoryRequirementCount, nullptr); | |
| sparseMemoryRequirements.resize(sparseMemoryRequirementCount); | |
| d.vkGetImageSparseMemoryRequirements2(m_device, | |
| reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>(&info), | |
| &sparseMemoryRequirementCount, | |
| reinterpret_cast<VkSparseImageMemoryRequirements2 *>(sparseMemoryRequirements.data())); | |
| VULKAN_HPP_ASSERT(sparseMemoryRequirementCount <= sparseMemoryRequirements.size()); | |
| return sparseMemoryRequirements; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void PhysicalDevice::getFeatures2(VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 *pFeatures, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkGetPhysicalDeviceFeatures2(m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2 *>(pFeatures)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 | |
| PhysicalDevice::getFeatures2(Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 features; | |
| d.vkGetPhysicalDeviceFeatures2(m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2 *>(&features)); | |
| return features; | |
| } | |
| template<typename X, typename Y, typename... Z, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getFeatures2(Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| StructureChain<X, Y, Z...> structureChain; | |
| VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 &features = structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2>(); | |
| d.vkGetPhysicalDeviceFeatures2(m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2 *>(&features)); | |
| return structureChain; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void PhysicalDevice::getProperties2(VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 *pProperties, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkGetPhysicalDeviceProperties2(m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2 *>(pProperties)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 | |
| PhysicalDevice::getProperties2(Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 properties; | |
| d.vkGetPhysicalDeviceProperties2(m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2 *>(&properties)); | |
| return properties; | |
| } | |
| template<typename X, typename Y, typename... Z, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getProperties2(Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| StructureChain<X, Y, Z...> structureChain; | |
| VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 &properties = structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2>(); | |
| d.vkGetPhysicalDeviceProperties2(m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2 *>(&properties)); | |
| return structureChain; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void PhysicalDevice::getFormatProperties2(VULKAN_HPP_NAMESPACE::Format format, | |
| VULKAN_HPP_NAMESPACE::FormatProperties2 *pFormatProperties, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkGetPhysicalDeviceFormatProperties2(m_physicalDevice, static_cast<VkFormat>(format), reinterpret_cast<VkFormatProperties2 *>(pFormatProperties)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::FormatProperties2 | |
| PhysicalDevice::getFormatProperties2(VULKAN_HPP_NAMESPACE::Format format, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::FormatProperties2 formatProperties; | |
| d.vkGetPhysicalDeviceFormatProperties2(m_physicalDevice, static_cast<VkFormat>(format), reinterpret_cast<VkFormatProperties2 *>(&formatProperties)); | |
| return formatProperties; | |
| } | |
| template<typename X, typename Y, typename... Z, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getFormatProperties2(VULKAN_HPP_NAMESPACE::Format format, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| StructureChain<X, Y, Z...> structureChain; | |
| VULKAN_HPP_NAMESPACE::FormatProperties2 &formatProperties = structureChain.template get<VULKAN_HPP_NAMESPACE::FormatProperties2>(); | |
| d.vkGetPhysicalDeviceFormatProperties2(m_physicalDevice, static_cast<VkFormat>(format), reinterpret_cast<VkFormatProperties2 *>(&formatProperties)); | |
| return structureChain; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| PhysicalDevice::getImageFormatProperties2(const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 *pImageFormatInfo, | |
| VULKAN_HPP_NAMESPACE::ImageFormatProperties2 *pImageFormatProperties, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkGetPhysicalDeviceImageFormatProperties2(m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>(pImageFormatInfo), | |
| reinterpret_cast<VkImageFormatProperties2 *>(pImageFormatProperties))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>::type | |
| PhysicalDevice::getImageFormatProperties2(const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 &imageFormatInfo, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::ImageFormatProperties2 imageFormatProperties; | |
| VkResult result = d.vkGetPhysicalDeviceImageFormatProperties2(m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>(&imageFormatInfo), | |
| reinterpret_cast<VkImageFormatProperties2 *>(&imageFormatProperties)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), imageFormatProperties); | |
| } | |
| template<typename X, typename Y, typename... Z, typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<StructureChain<X, Y, Z...>>::type | |
| PhysicalDevice::getImageFormatProperties2(const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 &imageFormatInfo, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| StructureChain<X, Y, Z...> structureChain; | |
| VULKAN_HPP_NAMESPACE::ImageFormatProperties2 &imageFormatProperties = structureChain.template get<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>(); | |
| Result result = | |
| static_cast<Result>(d.vkGetPhysicalDeviceImageFormatProperties2(m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>(&imageFormatInfo), | |
| reinterpret_cast<VkImageFormatProperties2 *>(&imageFormatProperties))); | |
| return createResultValue(result, structureChain, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2"); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void PhysicalDevice::getQueueFamilyProperties2(uint32_t *pQueueFamilyPropertyCount, | |
| VULKAN_HPP_NAMESPACE::QueueFamilyProperties2 *pQueueFamilyProperties, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkGetPhysicalDeviceQueueFamilyProperties2( | |
| m_physicalDevice, pQueueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2 *>(pQueueFamilyProperties)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename QueueFamilyProperties2Allocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator> | |
| PhysicalDevice::getQueueFamilyProperties2(Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator> queueFamilyProperties; | |
| uint32_t queueFamilyPropertyCount; | |
| d.vkGetPhysicalDeviceQueueFamilyProperties2(m_physicalDevice, &queueFamilyPropertyCount, nullptr); | |
| queueFamilyProperties.resize(queueFamilyPropertyCount); | |
| d.vkGetPhysicalDeviceQueueFamilyProperties2( | |
| m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2 *>(queueFamilyProperties.data())); | |
| VULKAN_HPP_ASSERT(queueFamilyPropertyCount <= queueFamilyProperties.size()); | |
| return queueFamilyProperties; | |
| } | |
| template<typename QueueFamilyProperties2Allocator, | |
| typename Dispatch, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, QueueFamilyProperties2>::value, int>::type> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator> | |
| PhysicalDevice::getQueueFamilyProperties2(QueueFamilyProperties2Allocator &queueFamilyProperties2Allocator, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator> queueFamilyProperties(queueFamilyProperties2Allocator); | |
| uint32_t queueFamilyPropertyCount; | |
| d.vkGetPhysicalDeviceQueueFamilyProperties2(m_physicalDevice, &queueFamilyPropertyCount, nullptr); | |
| queueFamilyProperties.resize(queueFamilyPropertyCount); | |
| d.vkGetPhysicalDeviceQueueFamilyProperties2( | |
| m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2 *>(queueFamilyProperties.data())); | |
| VULKAN_HPP_ASSERT(queueFamilyPropertyCount <= queueFamilyProperties.size()); | |
| return queueFamilyProperties; | |
| } | |
| template<typename StructureChain, typename StructureChainAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<StructureChain, StructureChainAllocator> | |
| PhysicalDevice::getQueueFamilyProperties2(Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| uint32_t queueFamilyPropertyCount; | |
| d.vkGetPhysicalDeviceQueueFamilyProperties2(m_physicalDevice, &queueFamilyPropertyCount, nullptr); | |
| std::vector<StructureChain, StructureChainAllocator> returnVector(queueFamilyPropertyCount); | |
| std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> queueFamilyProperties(queueFamilyPropertyCount); | |
| for(uint32_t i = 0; i < queueFamilyPropertyCount; i++) | |
| { | |
| queueFamilyProperties[i].pNext = returnVector[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>().pNext; | |
| } | |
| d.vkGetPhysicalDeviceQueueFamilyProperties2( | |
| m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2 *>(queueFamilyProperties.data())); | |
| VULKAN_HPP_ASSERT(queueFamilyPropertyCount <= queueFamilyProperties.size()); | |
| for(uint32_t i = 0; i < queueFamilyPropertyCount; i++) | |
| { | |
| returnVector[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>() = queueFamilyProperties[i]; | |
| } | |
| return returnVector; | |
| } | |
| template<typename StructureChain, | |
| typename StructureChainAllocator, | |
| typename Dispatch, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, StructureChain>::value, int>::type> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<StructureChain, StructureChainAllocator> | |
| PhysicalDevice::getQueueFamilyProperties2(StructureChainAllocator &structureChainAllocator, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| uint32_t queueFamilyPropertyCount; | |
| d.vkGetPhysicalDeviceQueueFamilyProperties2(m_physicalDevice, &queueFamilyPropertyCount, nullptr); | |
| std::vector<StructureChain, StructureChainAllocator> returnVector(queueFamilyPropertyCount, structureChainAllocator); | |
| std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> queueFamilyProperties(queueFamilyPropertyCount); | |
| for(uint32_t i = 0; i < queueFamilyPropertyCount; i++) | |
| { | |
| queueFamilyProperties[i].pNext = returnVector[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>().pNext; | |
| } | |
| d.vkGetPhysicalDeviceQueueFamilyProperties2( | |
| m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2 *>(queueFamilyProperties.data())); | |
| VULKAN_HPP_ASSERT(queueFamilyPropertyCount <= queueFamilyProperties.size()); | |
| for(uint32_t i = 0; i < queueFamilyPropertyCount; i++) | |
| { | |
| returnVector[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>() = queueFamilyProperties[i]; | |
| } | |
| return returnVector; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void PhysicalDevice::getMemoryProperties2(VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 *pMemoryProperties, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkGetPhysicalDeviceMemoryProperties2(m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>(pMemoryProperties)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 | |
| PhysicalDevice::getMemoryProperties2(Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 memoryProperties; | |
| d.vkGetPhysicalDeviceMemoryProperties2(m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>(&memoryProperties)); | |
| return memoryProperties; | |
| } | |
| template<typename X, typename Y, typename... Z, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getMemoryProperties2(Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| StructureChain<X, Y, Z...> structureChain; | |
| VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 &memoryProperties = | |
| structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2>(); | |
| d.vkGetPhysicalDeviceMemoryProperties2(m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>(&memoryProperties)); | |
| return structureChain; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void PhysicalDevice::getSparseImageFormatProperties2(const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, | |
| uint32_t *pPropertyCount, | |
| VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 *pProperties, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkGetPhysicalDeviceSparseImageFormatProperties2(m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>(pFormatInfo), | |
| pPropertyCount, | |
| reinterpret_cast<VkSparseImageFormatProperties2 *>(pProperties)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename SparseImageFormatProperties2Allocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator> | |
| PhysicalDevice::getSparseImageFormatProperties2(const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 &formatInfo, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator> properties; | |
| uint32_t propertyCount; | |
| d.vkGetPhysicalDeviceSparseImageFormatProperties2( | |
| m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>(&formatInfo), &propertyCount, nullptr); | |
| properties.resize(propertyCount); | |
| d.vkGetPhysicalDeviceSparseImageFormatProperties2(m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>(&formatInfo), | |
| &propertyCount, | |
| reinterpret_cast<VkSparseImageFormatProperties2 *>(properties.data())); | |
| VULKAN_HPP_ASSERT(propertyCount <= properties.size()); | |
| return properties; | |
| } | |
| template<typename SparseImageFormatProperties2Allocator, | |
| typename Dispatch, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, SparseImageFormatProperties2>::value, int>::type> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator> | |
| PhysicalDevice::getSparseImageFormatProperties2(const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 &formatInfo, | |
| SparseImageFormatProperties2Allocator &sparseImageFormatProperties2Allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator> properties(sparseImageFormatProperties2Allocator); | |
| uint32_t propertyCount; | |
| d.vkGetPhysicalDeviceSparseImageFormatProperties2( | |
| m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>(&formatInfo), &propertyCount, nullptr); | |
| properties.resize(propertyCount); | |
| d.vkGetPhysicalDeviceSparseImageFormatProperties2(m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>(&formatInfo), | |
| &propertyCount, | |
| reinterpret_cast<VkSparseImageFormatProperties2 *>(properties.data())); | |
| VULKAN_HPP_ASSERT(propertyCount <= properties.size()); | |
| return properties; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::trimCommandPool(VULKAN_HPP_NAMESPACE::CommandPool commandPool, | |
| VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkTrimCommandPool(m_device, static_cast<VkCommandPool>(commandPool), static_cast<VkCommandPoolTrimFlags>(flags)); | |
| } | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::getQueue2(const VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 *pQueueInfo, | |
| VULKAN_HPP_NAMESPACE::Queue *pQueue, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkGetDeviceQueue2(m_device, reinterpret_cast<const VkDeviceQueueInfo2 *>(pQueueInfo), reinterpret_cast<VkQueue *>(pQueue)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Queue Device::getQueue2(const VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 &queueInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::Queue queue; | |
| d.vkGetDeviceQueue2(m_device, reinterpret_cast<const VkDeviceQueueInfo2 *>(&queueInfo), reinterpret_cast<VkQueue *>(&queue)); | |
| return queue; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::createSamplerYcbcrConversion(const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo *pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion *pYcbcrConversion, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkCreateSamplerYcbcrConversion(m_device, | |
| reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo *>(pCreateInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(pAllocator), | |
| reinterpret_cast<VkSamplerYcbcrConversion *>(pYcbcrConversion))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>::type | |
| Device::createSamplerYcbcrConversion(const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion; | |
| VkResult 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)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::createSamplerYcbcrConversion"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), ycbcrConversion); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion, Dispatch>>::type | |
| Device::createSamplerYcbcrConversionUnique(const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion; | |
| Result result = static_cast<Result>(d.vkCreateSamplerYcbcrConversion( | |
| m_device, | |
| reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo *>(&createInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)), | |
| reinterpret_cast<VkSamplerYcbcrConversion *>(&ycbcrConversion))); | |
| ObjectDestroy<Device, Dispatch> deleter(*this, allocator, d); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion, Dispatch>( | |
| result, ycbcrConversion, VULKAN_HPP_NAMESPACE_STRING "::Device::createSamplerYcbcrConversionUnique", deleter); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroySamplerYcbcrConversion(VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroySamplerYcbcrConversion( | |
| m_device, static_cast<VkSamplerYcbcrConversion>(ycbcrConversion), reinterpret_cast<const VkAllocationCallbacks *>(pAllocator)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroySamplerYcbcrConversion(VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroySamplerYcbcrConversion( | |
| m_device, | |
| static_cast<VkSamplerYcbcrConversion>(ycbcrConversion), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy(VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroySamplerYcbcrConversion( | |
| m_device, static_cast<VkSamplerYcbcrConversion>(ycbcrConversion), reinterpret_cast<const VkAllocationCallbacks *>(pAllocator)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy(VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroySamplerYcbcrConversion( | |
| m_device, | |
| static_cast<VkSamplerYcbcrConversion>(ycbcrConversion), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::createDescriptorUpdateTemplate(const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo *pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate *pDescriptorUpdateTemplate, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkCreateDescriptorUpdateTemplate(m_device, | |
| reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo *>(pCreateInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(pAllocator), | |
| reinterpret_cast<VkDescriptorUpdateTemplate *>(pDescriptorUpdateTemplate))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate>::type | |
| Device::createDescriptorUpdateTemplate(const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate; | |
| VkResult 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)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorUpdateTemplate"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), descriptorUpdateTemplate); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate, Dispatch>>::type | |
| Device::createDescriptorUpdateTemplateUnique(const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate; | |
| Result result = static_cast<Result>(d.vkCreateDescriptorUpdateTemplate( | |
| m_device, | |
| reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo *>(&createInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)), | |
| reinterpret_cast<VkDescriptorUpdateTemplate *>(&descriptorUpdateTemplate))); | |
| ObjectDestroy<Device, Dispatch> deleter(*this, allocator, d); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate, Dispatch>( | |
| result, descriptorUpdateTemplate, VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorUpdateTemplateUnique", deleter); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplate(VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyDescriptorUpdateTemplate( | |
| m_device, static_cast<VkDescriptorUpdateTemplate>(descriptorUpdateTemplate), reinterpret_cast<const VkAllocationCallbacks *>(pAllocator)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplate(VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyDescriptorUpdateTemplate( | |
| m_device, | |
| static_cast<VkDescriptorUpdateTemplate>(descriptorUpdateTemplate), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy(VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyDescriptorUpdateTemplate( | |
| m_device, static_cast<VkDescriptorUpdateTemplate>(descriptorUpdateTemplate), reinterpret_cast<const VkAllocationCallbacks *>(pAllocator)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy(VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyDescriptorUpdateTemplate( | |
| m_device, | |
| static_cast<VkDescriptorUpdateTemplate>(descriptorUpdateTemplate), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::updateDescriptorSetWithTemplate(VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet, | |
| VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, | |
| const void *pData, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkUpdateDescriptorSetWithTemplate( | |
| m_device, static_cast<VkDescriptorSet>(descriptorSet), static_cast<VkDescriptorUpdateTemplate>(descriptorUpdateTemplate), pData); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename DataType, typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::updateDescriptorSetWithTemplate(VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet, | |
| VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, | |
| DataType const &data, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkUpdateDescriptorSetWithTemplate(m_device, | |
| static_cast<VkDescriptorSet>(descriptorSet), | |
| static_cast<VkDescriptorUpdateTemplate>(descriptorUpdateTemplate), | |
| reinterpret_cast<const void *>(&data)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void PhysicalDevice::getExternalBufferProperties(const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo *pExternalBufferInfo, | |
| VULKAN_HPP_NAMESPACE::ExternalBufferProperties *pExternalBufferProperties, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkGetPhysicalDeviceExternalBufferProperties(m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo *>(pExternalBufferInfo), | |
| reinterpret_cast<VkExternalBufferProperties *>(pExternalBufferProperties)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalBufferProperties | |
| PhysicalDevice::getExternalBufferProperties(const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo &externalBufferInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::ExternalBufferProperties externalBufferProperties; | |
| d.vkGetPhysicalDeviceExternalBufferProperties(m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo *>(&externalBufferInfo), | |
| reinterpret_cast<VkExternalBufferProperties *>(&externalBufferProperties)); | |
| return externalBufferProperties; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void PhysicalDevice::getExternalFenceProperties(const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo *pExternalFenceInfo, | |
| VULKAN_HPP_NAMESPACE::ExternalFenceProperties *pExternalFenceProperties, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkGetPhysicalDeviceExternalFenceProperties(m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo *>(pExternalFenceInfo), | |
| reinterpret_cast<VkExternalFenceProperties *>(pExternalFenceProperties)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalFenceProperties | |
| PhysicalDevice::getExternalFenceProperties(const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo &externalFenceInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::ExternalFenceProperties externalFenceProperties; | |
| d.vkGetPhysicalDeviceExternalFenceProperties(m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo *>(&externalFenceInfo), | |
| reinterpret_cast<VkExternalFenceProperties *>(&externalFenceProperties)); | |
| return externalFenceProperties; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| PhysicalDevice::getExternalSemaphoreProperties(const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo, | |
| VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties *pExternalSemaphoreProperties, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkGetPhysicalDeviceExternalSemaphoreProperties(m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo *>(pExternalSemaphoreInfo), | |
| reinterpret_cast<VkExternalSemaphoreProperties *>(pExternalSemaphoreProperties)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties | |
| PhysicalDevice::getExternalSemaphoreProperties(const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo &externalSemaphoreInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties externalSemaphoreProperties; | |
| d.vkGetPhysicalDeviceExternalSemaphoreProperties(m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo *>(&externalSemaphoreInfo), | |
| reinterpret_cast<VkExternalSemaphoreProperties *>(&externalSemaphoreProperties)); | |
| return externalSemaphoreProperties; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::getDescriptorSetLayoutSupport(const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo *pCreateInfo, | |
| VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport *pSupport, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkGetDescriptorSetLayoutSupport( | |
| m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>(pCreateInfo), reinterpret_cast<VkDescriptorSetLayoutSupport *>(pSupport)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport | |
| Device::getDescriptorSetLayoutSupport(const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo &createInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport support; | |
| d.vkGetDescriptorSetLayoutSupport( | |
| m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>(&createInfo), reinterpret_cast<VkDescriptorSetLayoutSupport *>(&support)); | |
| return support; | |
| } | |
| template<typename X, typename Y, typename... Z, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> | |
| Device::getDescriptorSetLayoutSupport(const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo &createInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| StructureChain<X, Y, Z...> structureChain; | |
| VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport &support = structureChain.template get<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport>(); | |
| d.vkGetDescriptorSetLayoutSupport( | |
| m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>(&createInfo), reinterpret_cast<VkDescriptorSetLayoutSupport *>(&support)); | |
| return structureChain; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_VERSION_1_2 === | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCount(VULKAN_HPP_NAMESPACE::Buffer buffer, | |
| VULKAN_HPP_NAMESPACE::DeviceSize offset, | |
| VULKAN_HPP_NAMESPACE::Buffer countBuffer, | |
| VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, | |
| uint32_t maxDrawCount, | |
| uint32_t stride, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdDrawIndirectCount(m_commandBuffer, | |
| static_cast<VkBuffer>(buffer), | |
| static_cast<VkDeviceSize>(offset), | |
| static_cast<VkBuffer>(countBuffer), | |
| static_cast<VkDeviceSize>(countBufferOffset), | |
| maxDrawCount, | |
| stride); | |
| } | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCount(VULKAN_HPP_NAMESPACE::Buffer buffer, | |
| VULKAN_HPP_NAMESPACE::DeviceSize offset, | |
| VULKAN_HPP_NAMESPACE::Buffer countBuffer, | |
| VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, | |
| uint32_t maxDrawCount, | |
| uint32_t stride, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdDrawIndexedIndirectCount(m_commandBuffer, | |
| static_cast<VkBuffer>(buffer), | |
| static_cast<VkDeviceSize>(offset), | |
| static_cast<VkBuffer>(countBuffer), | |
| static_cast<VkDeviceSize>(countBufferOffset), | |
| maxDrawCount, | |
| stride); | |
| } | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createRenderPass2(const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 *pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| VULKAN_HPP_NAMESPACE::RenderPass *pRenderPass, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkCreateRenderPass2(m_device, | |
| reinterpret_cast<const VkRenderPassCreateInfo2 *>(pCreateInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(pAllocator), | |
| reinterpret_cast<VkRenderPass *>(pRenderPass))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::RenderPass>::type | |
| Device::createRenderPass2(const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::RenderPass renderPass; | |
| VkResult 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)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPass2"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), renderPass); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>>::type | |
| Device::createRenderPass2Unique(const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::RenderPass renderPass; | |
| Result result = static_cast<Result>( | |
| d.vkCreateRenderPass2(m_device, | |
| reinterpret_cast<const VkRenderPassCreateInfo2 *>(&createInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)), | |
| reinterpret_cast<VkRenderPass *>(&renderPass))); | |
| ObjectDestroy<Device, Dispatch> deleter(*this, allocator, d); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>( | |
| result, renderPass, VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPass2Unique", deleter); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass2(const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo *pRenderPassBegin, | |
| const VULKAN_HPP_NAMESPACE::SubpassBeginInfo *pSubpassBeginInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdBeginRenderPass2( | |
| m_commandBuffer, reinterpret_cast<const VkRenderPassBeginInfo *>(pRenderPassBegin), reinterpret_cast<const VkSubpassBeginInfo *>(pSubpassBeginInfo)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass2(const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo &renderPassBegin, | |
| const VULKAN_HPP_NAMESPACE::SubpassBeginInfo &subpassBeginInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdBeginRenderPass2( | |
| m_commandBuffer, reinterpret_cast<const VkRenderPassBeginInfo *>(&renderPassBegin), reinterpret_cast<const VkSubpassBeginInfo *>(&subpassBeginInfo)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::nextSubpass2(const VULKAN_HPP_NAMESPACE::SubpassBeginInfo *pSubpassBeginInfo, | |
| const VULKAN_HPP_NAMESPACE::SubpassEndInfo *pSubpassEndInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdNextSubpass2( | |
| m_commandBuffer, reinterpret_cast<const VkSubpassBeginInfo *>(pSubpassBeginInfo), reinterpret_cast<const VkSubpassEndInfo *>(pSubpassEndInfo)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::nextSubpass2(const VULKAN_HPP_NAMESPACE::SubpassBeginInfo &subpassBeginInfo, | |
| const VULKAN_HPP_NAMESPACE::SubpassEndInfo &subpassEndInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdNextSubpass2( | |
| m_commandBuffer, reinterpret_cast<const VkSubpassBeginInfo *>(&subpassBeginInfo), reinterpret_cast<const VkSubpassEndInfo *>(&subpassEndInfo)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::endRenderPass2(const VULKAN_HPP_NAMESPACE::SubpassEndInfo *pSubpassEndInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdEndRenderPass2(m_commandBuffer, reinterpret_cast<const VkSubpassEndInfo *>(pSubpassEndInfo)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::endRenderPass2(const VULKAN_HPP_NAMESPACE::SubpassEndInfo &subpassEndInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdEndRenderPass2(m_commandBuffer, reinterpret_cast<const VkSubpassEndInfo *>(&subpassEndInfo)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| Device::resetQueryPool(VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkResetQueryPool(m_device, static_cast<VkQueryPool>(queryPool), firstQuery, queryCount); | |
| } | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSemaphoreCounterValue(VULKAN_HPP_NAMESPACE::Semaphore semaphore, | |
| uint64_t *pValue, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkGetSemaphoreCounterValue(m_device, static_cast<VkSemaphore>(semaphore), pValue)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD 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; | |
| VkResult result = d.vkGetSemaphoreCounterValue(m_device, static_cast<VkSemaphore>(semaphore), &value); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreCounterValue"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), value); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::waitSemaphores(const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo *pWaitInfo, | |
| uint64_t timeout, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkWaitSemaphores(m_device, reinterpret_cast<const VkSemaphoreWaitInfo *>(pWaitInfo), timeout)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result | |
| Device::waitSemaphores(const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo &waitInfo, uint64_t timeout, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VkResult result = d.vkWaitSemaphores(m_device, reinterpret_cast<const VkSemaphoreWaitInfo *>(&waitInfo), timeout); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::waitSemaphores", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eTimeout }); | |
| return static_cast<VULKAN_HPP_NAMESPACE::Result>(result); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::signalSemaphore(const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo *pSignalInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkSignalSemaphore(m_device, reinterpret_cast<const VkSemaphoreSignalInfo *>(pSignalInfo))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| Device::signalSemaphore(const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo &signalInfo, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VkResult result = d.vkSignalSemaphore(m_device, reinterpret_cast<const VkSemaphoreSignalInfo *>(&signalInfo)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::signalSemaphore"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddress(const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo *pInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<DeviceAddress>(d.vkGetBufferDeviceAddress(m_device, reinterpret_cast<const VkBufferDeviceAddressInfo *>(pInfo))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceAddress Device::getBufferAddress(const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo &info, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VkDeviceAddress result = d.vkGetBufferDeviceAddress(m_device, reinterpret_cast<const VkBufferDeviceAddressInfo *>(&info)); | |
| return static_cast<VULKAN_HPP_NAMESPACE::DeviceAddress>(result); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE uint64_t Device::getBufferOpaqueCaptureAddress(const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo *pInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return d.vkGetBufferOpaqueCaptureAddress(m_device, reinterpret_cast<const VkBufferDeviceAddressInfo *>(pInfo)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE uint64_t Device::getBufferOpaqueCaptureAddress(const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo &info, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| uint64_t result = d.vkGetBufferOpaqueCaptureAddress(m_device, reinterpret_cast<const VkBufferDeviceAddressInfo *>(&info)); | |
| return result; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE uint64_t Device::getMemoryOpaqueCaptureAddress(const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo *pInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return d.vkGetDeviceMemoryOpaqueCaptureAddress(m_device, reinterpret_cast<const VkDeviceMemoryOpaqueCaptureAddressInfo *>(pInfo)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE uint64_t Device::getMemoryOpaqueCaptureAddress(const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo &info, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| uint64_t result = d.vkGetDeviceMemoryOpaqueCaptureAddress(m_device, reinterpret_cast<const VkDeviceMemoryOpaqueCaptureAddressInfo *>(&info)); | |
| return result; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_VERSION_1_3 === | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getToolProperties(uint32_t *pToolCount, | |
| VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties *pToolProperties, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>( | |
| d.vkGetPhysicalDeviceToolProperties(m_physicalDevice, pToolCount, reinterpret_cast<VkPhysicalDeviceToolProperties *>(pToolProperties))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename PhysicalDeviceToolPropertiesAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator>>::type | |
| PhysicalDevice::getToolProperties(Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| std::vector<PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator> toolProperties; | |
| uint32_t toolCount; | |
| Result result; | |
| do | |
| { | |
| result = static_cast<Result>(d.vkGetPhysicalDeviceToolProperties(m_physicalDevice, &toolCount, nullptr)); | |
| if((result == Result::eSuccess) && toolCount) | |
| { | |
| toolProperties.resize(toolCount); | |
| result = static_cast<Result>( | |
| d.vkGetPhysicalDeviceToolProperties(m_physicalDevice, &toolCount, reinterpret_cast<VkPhysicalDeviceToolProperties *>(toolProperties.data()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(toolCount <= toolProperties.size()); | |
| if(toolCount < toolProperties.size()) | |
| { | |
| toolProperties.resize(toolCount); | |
| } | |
| } | |
| return createResultValue(result, toolProperties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getToolProperties"); | |
| } | |
| template<typename PhysicalDeviceToolPropertiesAllocator, | |
| typename Dispatch, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, PhysicalDeviceToolProperties>::value, int>::type> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator>>::type | |
| PhysicalDevice::getToolProperties(PhysicalDeviceToolPropertiesAllocator &physicalDeviceToolPropertiesAllocator, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| std::vector<PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator> toolProperties(physicalDeviceToolPropertiesAllocator); | |
| uint32_t toolCount; | |
| Result result; | |
| do | |
| { | |
| result = static_cast<Result>(d.vkGetPhysicalDeviceToolProperties(m_physicalDevice, &toolCount, nullptr)); | |
| if((result == Result::eSuccess) && toolCount) | |
| { | |
| toolProperties.resize(toolCount); | |
| result = static_cast<Result>( | |
| d.vkGetPhysicalDeviceToolProperties(m_physicalDevice, &toolCount, reinterpret_cast<VkPhysicalDeviceToolProperties *>(toolProperties.data()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(toolCount <= toolProperties.size()); | |
| if(toolCount < toolProperties.size()) | |
| { | |
| toolProperties.resize(toolCount); | |
| } | |
| } | |
| return createResultValue(result, toolProperties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getToolProperties"); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createPrivateDataSlot(const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo *pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| VULKAN_HPP_NAMESPACE::PrivateDataSlot *pPrivateDataSlot, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkCreatePrivateDataSlot(m_device, | |
| reinterpret_cast<const VkPrivateDataSlotCreateInfo *>(pCreateInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(pAllocator), | |
| reinterpret_cast<VkPrivateDataSlot *>(pPrivateDataSlot))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::PrivateDataSlot>::type | |
| Device::createPrivateDataSlot(const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot; | |
| VkResult result = | |
| d.vkCreatePrivateDataSlot(m_device, | |
| reinterpret_cast<const VkPrivateDataSlotCreateInfo *>(&createInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)), | |
| reinterpret_cast<VkPrivateDataSlot *>(&privateDataSlot)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::createPrivateDataSlot"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), privateDataSlot); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PrivateDataSlot, Dispatch>>::type | |
| Device::createPrivateDataSlotUnique(const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot; | |
| Result result = static_cast<Result>( | |
| d.vkCreatePrivateDataSlot(m_device, | |
| reinterpret_cast<const VkPrivateDataSlotCreateInfo *>(&createInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)), | |
| reinterpret_cast<VkPrivateDataSlot *>(&privateDataSlot))); | |
| ObjectDestroy<Device, Dispatch> deleter(*this, allocator, d); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::PrivateDataSlot, Dispatch>( | |
| result, privateDataSlot, VULKAN_HPP_NAMESPACE_STRING "::Device::createPrivateDataSlotUnique", deleter); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroyPrivateDataSlot(VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyPrivateDataSlot(m_device, static_cast<VkPrivateDataSlot>(privateDataSlot), reinterpret_cast<const VkAllocationCallbacks *>(pAllocator)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroyPrivateDataSlot(VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyPrivateDataSlot( | |
| m_device, | |
| static_cast<VkPrivateDataSlot>(privateDataSlot), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy(VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyPrivateDataSlot(m_device, static_cast<VkPrivateDataSlot>(privateDataSlot), reinterpret_cast<const VkAllocationCallbacks *>(pAllocator)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy(VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyPrivateDataSlot( | |
| m_device, | |
| static_cast<VkPrivateDataSlot>(privateDataSlot), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::setPrivateData(VULKAN_HPP_NAMESPACE::ObjectType objectType, | |
| uint64_t objectHandle, | |
| VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, | |
| uint64_t data, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>( | |
| d.vkSetPrivateData(m_device, static_cast<VkObjectType>(objectType), objectHandle, static_cast<VkPrivateDataSlot>(privateDataSlot), data)); | |
| } | |
| #else | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::setPrivateData(VULKAN_HPP_NAMESPACE::ObjectType objectType, | |
| uint64_t objectHandle, | |
| VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, | |
| uint64_t data, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VkResult result = | |
| d.vkSetPrivateData(m_device, static_cast<VkObjectType>(objectType), objectHandle, static_cast<VkPrivateDataSlot>(privateDataSlot), data); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::setPrivateData"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::getPrivateData(VULKAN_HPP_NAMESPACE::ObjectType objectType, | |
| uint64_t objectHandle, | |
| VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, | |
| uint64_t *pData, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkGetPrivateData(m_device, static_cast<VkObjectType>(objectType), objectHandle, static_cast<VkPrivateDataSlot>(privateDataSlot), pData); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t Device::getPrivateData(VULKAN_HPP_NAMESPACE::ObjectType objectType, | |
| uint64_t objectHandle, | |
| VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| uint64_t data; | |
| d.vkGetPrivateData(m_device, static_cast<VkObjectType>(objectType), objectHandle, static_cast<VkPrivateDataSlot>(privateDataSlot), &data); | |
| return data; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setEvent2(VULKAN_HPP_NAMESPACE::Event event, | |
| const VULKAN_HPP_NAMESPACE::DependencyInfo *pDependencyInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdSetEvent2(m_commandBuffer, static_cast<VkEvent>(event), reinterpret_cast<const VkDependencyInfo *>(pDependencyInfo)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setEvent2(VULKAN_HPP_NAMESPACE::Event event, | |
| const VULKAN_HPP_NAMESPACE::DependencyInfo &dependencyInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdSetEvent2(m_commandBuffer, static_cast<VkEvent>(event), reinterpret_cast<const VkDependencyInfo *>(&dependencyInfo)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::resetEvent2(VULKAN_HPP_NAMESPACE::Event event, | |
| VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stageMask, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdResetEvent2(m_commandBuffer, static_cast<VkEvent>(event), static_cast<VkPipelineStageFlags2>(stageMask)); | |
| } | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::waitEvents2(uint32_t eventCount, | |
| const VULKAN_HPP_NAMESPACE::Event *pEvents, | |
| const VULKAN_HPP_NAMESPACE::DependencyInfo *pDependencyInfos, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdWaitEvents2( | |
| m_commandBuffer, eventCount, reinterpret_cast<const VkEvent *>(pEvents), reinterpret_cast<const VkDependencyInfo *>(pDependencyInfos)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::waitEvents2(ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const &events, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::DependencyInfo> const &dependencyInfos, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| # ifdef VULKAN_HPP_NO_EXCEPTIONS | |
| VULKAN_HPP_ASSERT(events.size() == dependencyInfos.size()); | |
| # else | |
| if(events.size() != dependencyInfos.size()) | |
| { | |
| throw LogicError(VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::waitEvents2: events.size() != dependencyInfos.size()"); | |
| } | |
| # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ | |
| d.vkCmdWaitEvents2(m_commandBuffer, | |
| events.size(), | |
| reinterpret_cast<const VkEvent *>(events.data()), | |
| reinterpret_cast<const VkDependencyInfo *>(dependencyInfos.data())); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier2(const VULKAN_HPP_NAMESPACE::DependencyInfo *pDependencyInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdPipelineBarrier2(m_commandBuffer, reinterpret_cast<const VkDependencyInfo *>(pDependencyInfo)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier2(const VULKAN_HPP_NAMESPACE::DependencyInfo &dependencyInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdPipelineBarrier2(m_commandBuffer, reinterpret_cast<const VkDependencyInfo *>(&dependencyInfo)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::writeTimestamp2(VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stage, | |
| VULKAN_HPP_NAMESPACE::QueryPool queryPool, | |
| uint32_t query, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdWriteTimestamp2(m_commandBuffer, static_cast<VkPipelineStageFlags2>(stage), static_cast<VkQueryPool>(queryPool), query); | |
| } | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Queue::submit2(uint32_t submitCount, | |
| const VULKAN_HPP_NAMESPACE::SubmitInfo2 *pSubmits, | |
| VULKAN_HPP_NAMESPACE::Fence fence, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkQueueSubmit2(m_queue, submitCount, reinterpret_cast<const VkSubmitInfo2 *>(pSubmits), static_cast<VkFence>(fence))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| Queue::submit2(ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo2> const &submits, VULKAN_HPP_NAMESPACE::Fence fence, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VkResult result = d.vkQueueSubmit2(m_queue, submits.size(), reinterpret_cast<const VkSubmitInfo2 *>(submits.data()), static_cast<VkFence>(fence)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Queue::submit2"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::copyBuffer2(const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 *pCopyBufferInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdCopyBuffer2(m_commandBuffer, reinterpret_cast<const VkCopyBufferInfo2 *>(pCopyBufferInfo)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::copyBuffer2(const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 ©BufferInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdCopyBuffer2(m_commandBuffer, reinterpret_cast<const VkCopyBufferInfo2 *>(©BufferInfo)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::copyImage2(const VULKAN_HPP_NAMESPACE::CopyImageInfo2 *pCopyImageInfo, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdCopyImage2(m_commandBuffer, reinterpret_cast<const VkCopyImageInfo2 *>(pCopyImageInfo)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::copyImage2(const VULKAN_HPP_NAMESPACE::CopyImageInfo2 ©ImageInfo, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdCopyImage2(m_commandBuffer, reinterpret_cast<const VkCopyImageInfo2 *>(©ImageInfo)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage2(const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 *pCopyBufferToImageInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdCopyBufferToImage2(m_commandBuffer, reinterpret_cast<const VkCopyBufferToImageInfo2 *>(pCopyBufferToImageInfo)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage2(const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 ©BufferToImageInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdCopyBufferToImage2(m_commandBuffer, reinterpret_cast<const VkCopyBufferToImageInfo2 *>(©BufferToImageInfo)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer2(const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 *pCopyImageToBufferInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdCopyImageToBuffer2(m_commandBuffer, reinterpret_cast<const VkCopyImageToBufferInfo2 *>(pCopyImageToBufferInfo)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer2(const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 ©ImageToBufferInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdCopyImageToBuffer2(m_commandBuffer, reinterpret_cast<const VkCopyImageToBufferInfo2 *>(©ImageToBufferInfo)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::blitImage2(const VULKAN_HPP_NAMESPACE::BlitImageInfo2 *pBlitImageInfo, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdBlitImage2(m_commandBuffer, reinterpret_cast<const VkBlitImageInfo2 *>(pBlitImageInfo)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::blitImage2(const VULKAN_HPP_NAMESPACE::BlitImageInfo2 &blitImageInfo, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdBlitImage2(m_commandBuffer, reinterpret_cast<const VkBlitImageInfo2 *>(&blitImageInfo)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::resolveImage2(const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 *pResolveImageInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdResolveImage2(m_commandBuffer, reinterpret_cast<const VkResolveImageInfo2 *>(pResolveImageInfo)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::resolveImage2(const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 &resolveImageInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdResolveImage2(m_commandBuffer, reinterpret_cast<const VkResolveImageInfo2 *>(&resolveImageInfo)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::beginRendering(const VULKAN_HPP_NAMESPACE::RenderingInfo *pRenderingInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdBeginRendering(m_commandBuffer, reinterpret_cast<const VkRenderingInfo *>(pRenderingInfo)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::beginRendering(const VULKAN_HPP_NAMESPACE::RenderingInfo &renderingInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdBeginRendering(m_commandBuffer, reinterpret_cast<const VkRenderingInfo *>(&renderingInfo)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::endRendering(Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdEndRendering(m_commandBuffer); | |
| } | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setCullMode(VULKAN_HPP_NAMESPACE::CullModeFlags cullMode, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdSetCullMode(m_commandBuffer, static_cast<VkCullModeFlags>(cullMode)); | |
| } | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setFrontFace(VULKAN_HPP_NAMESPACE::FrontFace frontFace, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdSetFrontFace(m_commandBuffer, static_cast<VkFrontFace>(frontFace)); | |
| } | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setPrimitiveTopology(VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdSetPrimitiveTopology(m_commandBuffer, static_cast<VkPrimitiveTopology>(primitiveTopology)); | |
| } | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setViewportWithCount(uint32_t viewportCount, | |
| const VULKAN_HPP_NAMESPACE::Viewport *pViewports, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdSetViewportWithCount(m_commandBuffer, viewportCount, reinterpret_cast<const VkViewport *>(pViewports)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setViewportWithCount(ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const &viewports, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdSetViewportWithCount(m_commandBuffer, viewports.size(), reinterpret_cast<const VkViewport *>(viewports.data())); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::setScissorWithCount(uint32_t scissorCount, const VULKAN_HPP_NAMESPACE::Rect2D *pScissors, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdSetScissorWithCount(m_commandBuffer, scissorCount, reinterpret_cast<const VkRect2D *>(pScissors)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setScissorWithCount(ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const &scissors, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdSetScissorWithCount(m_commandBuffer, scissors.size(), reinterpret_cast<const VkRect2D *>(scissors.data())); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers2(uint32_t firstBinding, | |
| uint32_t bindingCount, | |
| const VULKAN_HPP_NAMESPACE::Buffer *pBuffers, | |
| const VULKAN_HPP_NAMESPACE::DeviceSize *pOffsets, | |
| const VULKAN_HPP_NAMESPACE::DeviceSize *pSizes, | |
| const VULKAN_HPP_NAMESPACE::DeviceSize *pStrides, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdBindVertexBuffers2(m_commandBuffer, | |
| firstBinding, | |
| bindingCount, | |
| reinterpret_cast<const VkBuffer *>(pBuffers), | |
| reinterpret_cast<const VkDeviceSize *>(pOffsets), | |
| reinterpret_cast<const VkDeviceSize *>(pSizes), | |
| reinterpret_cast<const VkDeviceSize *>(pStrides)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers2(uint32_t firstBinding, | |
| 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::bindVertexBuffers2: buffers.size() != offsets.size()"); | |
| } | |
| if(!sizes.empty() && buffers.size() != sizes.size()) | |
| { | |
| throw LogicError(VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers2: buffers.size() != sizes.size()"); | |
| } | |
| if(!strides.empty() && buffers.size() != strides.size()) | |
| { | |
| throw LogicError(VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers2: buffers.size() != strides.size()"); | |
| } | |
| # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ | |
| d.vkCmdBindVertexBuffers2(m_commandBuffer, | |
| firstBinding, | |
| buffers.size(), | |
| reinterpret_cast<const VkBuffer *>(buffers.data()), | |
| reinterpret_cast<const VkDeviceSize *>(offsets.data()), | |
| reinterpret_cast<const VkDeviceSize *>(sizes.data()), | |
| reinterpret_cast<const VkDeviceSize *>(strides.data())); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setDepthTestEnable(VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdSetDepthTestEnable(m_commandBuffer, static_cast<VkBool32>(depthTestEnable)); | |
| } | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setDepthWriteEnable(VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdSetDepthWriteEnable(m_commandBuffer, static_cast<VkBool32>(depthWriteEnable)); | |
| } | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setDepthCompareOp(VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdSetDepthCompareOp(m_commandBuffer, static_cast<VkCompareOp>(depthCompareOp)); | |
| } | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setDepthBoundsTestEnable(VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdSetDepthBoundsTestEnable(m_commandBuffer, static_cast<VkBool32>(depthBoundsTestEnable)); | |
| } | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setStencilTestEnable(VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdSetStencilTestEnable(m_commandBuffer, static_cast<VkBool32>(stencilTestEnable)); | |
| } | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setStencilOp(VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, | |
| VULKAN_HPP_NAMESPACE::StencilOp failOp, | |
| VULKAN_HPP_NAMESPACE::StencilOp passOp, | |
| VULKAN_HPP_NAMESPACE::StencilOp depthFailOp, | |
| VULKAN_HPP_NAMESPACE::CompareOp compareOp, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdSetStencilOp(m_commandBuffer, | |
| static_cast<VkStencilFaceFlags>(faceMask), | |
| static_cast<VkStencilOp>(failOp), | |
| static_cast<VkStencilOp>(passOp), | |
| static_cast<VkStencilOp>(depthFailOp), | |
| static_cast<VkCompareOp>(compareOp)); | |
| } | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setRasterizerDiscardEnable(VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdSetRasterizerDiscardEnable(m_commandBuffer, static_cast<VkBool32>(rasterizerDiscardEnable)); | |
| } | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setDepthBiasEnable(VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdSetDepthBiasEnable(m_commandBuffer, static_cast<VkBool32>(depthBiasEnable)); | |
| } | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setPrimitiveRestartEnable(VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdSetPrimitiveRestartEnable(m_commandBuffer, static_cast<VkBool32>(primitiveRestartEnable)); | |
| } | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::getBufferMemoryRequirements(const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements *pInfo, | |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 *pMemoryRequirements, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkGetDeviceBufferMemoryRequirements( | |
| m_device, reinterpret_cast<const VkDeviceBufferMemoryRequirements *>(pInfo), reinterpret_cast<VkMemoryRequirements2 *>(pMemoryRequirements)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2 | |
| Device::getBufferMemoryRequirements(const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements &info, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements; | |
| d.vkGetDeviceBufferMemoryRequirements( | |
| m_device, reinterpret_cast<const VkDeviceBufferMemoryRequirements *>(&info), reinterpret_cast<VkMemoryRequirements2 *>(&memoryRequirements)); | |
| return memoryRequirements; | |
| } | |
| template<typename X, typename Y, typename... Z, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> | |
| Device::getBufferMemoryRequirements(const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements &info, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| StructureChain<X, Y, Z...> structureChain; | |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 &memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>(); | |
| d.vkGetDeviceBufferMemoryRequirements( | |
| m_device, reinterpret_cast<const VkDeviceBufferMemoryRequirements *>(&info), reinterpret_cast<VkMemoryRequirements2 *>(&memoryRequirements)); | |
| return structureChain; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::getImageMemoryRequirements(const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements *pInfo, | |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 *pMemoryRequirements, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkGetDeviceImageMemoryRequirements( | |
| m_device, reinterpret_cast<const VkDeviceImageMemoryRequirements *>(pInfo), reinterpret_cast<VkMemoryRequirements2 *>(pMemoryRequirements)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2 | |
| Device::getImageMemoryRequirements(const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements &info, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements; | |
| d.vkGetDeviceImageMemoryRequirements( | |
| m_device, reinterpret_cast<const VkDeviceImageMemoryRequirements *>(&info), reinterpret_cast<VkMemoryRequirements2 *>(&memoryRequirements)); | |
| return memoryRequirements; | |
| } | |
| template<typename X, typename Y, typename... Z, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> | |
| Device::getImageMemoryRequirements(const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements &info, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| StructureChain<X, Y, Z...> structureChain; | |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 &memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>(); | |
| d.vkGetDeviceImageMemoryRequirements( | |
| m_device, reinterpret_cast<const VkDeviceImageMemoryRequirements *>(&info), reinterpret_cast<VkMemoryRequirements2 *>(&memoryRequirements)); | |
| return structureChain; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirements(const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements *pInfo, | |
| uint32_t *pSparseMemoryRequirementCount, | |
| VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 *pSparseMemoryRequirements, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkGetDeviceImageSparseMemoryRequirements(m_device, | |
| reinterpret_cast<const VkDeviceImageMemoryRequirements *>(pInfo), | |
| pSparseMemoryRequirementCount, | |
| reinterpret_cast<VkSparseImageMemoryRequirements2 *>(pSparseMemoryRequirements)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename SparseImageMemoryRequirements2Allocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> | |
| Device::getImageSparseMemoryRequirements(const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements &info, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> sparseMemoryRequirements; | |
| uint32_t sparseMemoryRequirementCount; | |
| d.vkGetDeviceImageSparseMemoryRequirements( | |
| m_device, reinterpret_cast<const VkDeviceImageMemoryRequirements *>(&info), &sparseMemoryRequirementCount, nullptr); | |
| sparseMemoryRequirements.resize(sparseMemoryRequirementCount); | |
| d.vkGetDeviceImageSparseMemoryRequirements(m_device, | |
| reinterpret_cast<const VkDeviceImageMemoryRequirements *>(&info), | |
| &sparseMemoryRequirementCount, | |
| reinterpret_cast<VkSparseImageMemoryRequirements2 *>(sparseMemoryRequirements.data())); | |
| VULKAN_HPP_ASSERT(sparseMemoryRequirementCount <= sparseMemoryRequirements.size()); | |
| 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::getImageSparseMemoryRequirements(const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements &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.vkGetDeviceImageSparseMemoryRequirements( | |
| m_device, reinterpret_cast<const VkDeviceImageMemoryRequirements *>(&info), &sparseMemoryRequirementCount, nullptr); | |
| sparseMemoryRequirements.resize(sparseMemoryRequirementCount); | |
| d.vkGetDeviceImageSparseMemoryRequirements(m_device, | |
| reinterpret_cast<const VkDeviceImageMemoryRequirements *>(&info), | |
| &sparseMemoryRequirementCount, | |
| reinterpret_cast<VkSparseImageMemoryRequirements2 *>(sparseMemoryRequirements.data())); | |
| VULKAN_HPP_ASSERT(sparseMemoryRequirementCount <= sparseMemoryRequirements.size()); | |
| return sparseMemoryRequirements; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_KHR_surface === | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Instance::destroySurfaceKHR(VULKAN_HPP_NAMESPACE::SurfaceKHR surface, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroySurfaceKHR(m_instance, static_cast<VkSurfaceKHR>(surface), reinterpret_cast<const VkAllocationCallbacks *>(pAllocator)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Instance::destroySurfaceKHR(VULKAN_HPP_NAMESPACE::SurfaceKHR surface, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroySurfaceKHR(m_instance, | |
| static_cast<VkSurfaceKHR>(surface), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Instance::destroy(VULKAN_HPP_NAMESPACE::SurfaceKHR surface, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroySurfaceKHR(m_instance, static_cast<VkSurfaceKHR>(surface), reinterpret_cast<const VkAllocationCallbacks *>(pAllocator)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Instance::destroy(VULKAN_HPP_NAMESPACE::SurfaceKHR surface, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroySurfaceKHR(m_instance, | |
| static_cast<VkSurfaceKHR>(surface), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceSupportKHR(uint32_t queueFamilyIndex, | |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface, | |
| VULKAN_HPP_NAMESPACE::Bool32 *pSupported, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkGetPhysicalDeviceSurfaceSupportKHR( | |
| m_physicalDevice, queueFamilyIndex, static_cast<VkSurfaceKHR>(surface), reinterpret_cast<VkBool32 *>(pSupported))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD 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; | |
| VkResult result = d.vkGetPhysicalDeviceSurfaceSupportKHR( | |
| m_physicalDevice, queueFamilyIndex, static_cast<VkSurfaceKHR>(surface), reinterpret_cast<VkBool32 *>(&supported)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceSupportKHR"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), supported); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceCapabilitiesKHR(VULKAN_HPP_NAMESPACE::SurfaceKHR surface, | |
| VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR *pSurfaceCapabilities, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkGetPhysicalDeviceSurfaceCapabilitiesKHR( | |
| m_physicalDevice, static_cast<VkSurfaceKHR>(surface), reinterpret_cast<VkSurfaceCapabilitiesKHR *>(pSurfaceCapabilities))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR>::type | |
| PhysicalDevice::getSurfaceCapabilitiesKHR(VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR surfaceCapabilities; | |
| VkResult result = d.vkGetPhysicalDeviceSurfaceCapabilitiesKHR( | |
| m_physicalDevice, static_cast<VkSurfaceKHR>(surface), reinterpret_cast<VkSurfaceCapabilitiesKHR *>(&surfaceCapabilities)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilitiesKHR"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), surfaceCapabilities); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceFormatsKHR(VULKAN_HPP_NAMESPACE::SurfaceKHR surface, | |
| uint32_t *pSurfaceFormatCount, | |
| VULKAN_HPP_NAMESPACE::SurfaceFormatKHR *pSurfaceFormats, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkGetPhysicalDeviceSurfaceFormatsKHR( | |
| m_physicalDevice, static_cast<VkSurfaceKHR>(surface), pSurfaceFormatCount, reinterpret_cast<VkSurfaceFormatKHR *>(pSurfaceFormats))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename SurfaceFormatKHRAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<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()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(surfaceFormatCount <= surfaceFormats.size()); | |
| if(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()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(surfaceFormatCount <= surfaceFormats.size()); | |
| if(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()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(presentModeCount <= presentModes.size()); | |
| if(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()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(presentModeCount <= presentModes.size()); | |
| if(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 VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::SwapchainKHR>::type | |
| Device::createSwapchainKHR(const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain; | |
| VkResult 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)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::createSwapchainKHR"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), swapchain); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>>::type | |
| Device::createSwapchainKHRUnique(const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain; | |
| Result result = static_cast<Result>( | |
| d.vkCreateSwapchainKHR(m_device, | |
| reinterpret_cast<const VkSwapchainCreateInfoKHR *>(&createInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)), | |
| reinterpret_cast<VkSwapchainKHR *>(&swapchain))); | |
| ObjectDestroy<Device, Dispatch> deleter(*this, allocator, d); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>( | |
| result, swapchain, VULKAN_HPP_NAMESPACE_STRING "::Device::createSwapchainKHRUnique", deleter); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroySwapchainKHR(VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroySwapchainKHR(m_device, static_cast<VkSwapchainKHR>(swapchain), reinterpret_cast<const VkAllocationCallbacks *>(pAllocator)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroySwapchainKHR(VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroySwapchainKHR(m_device, | |
| static_cast<VkSwapchainKHR>(swapchain), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy(VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroySwapchainKHR(m_device, static_cast<VkSwapchainKHR>(swapchain), reinterpret_cast<const VkAllocationCallbacks *>(pAllocator)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy(VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroySwapchainKHR(m_device, | |
| static_cast<VkSwapchainKHR>(swapchain), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSwapchainImagesKHR(VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, | |
| uint32_t *pSwapchainImageCount, | |
| VULKAN_HPP_NAMESPACE::Image *pSwapchainImages, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>( | |
| d.vkGetSwapchainImagesKHR(m_device, static_cast<VkSwapchainKHR>(swapchain), pSwapchainImageCount, reinterpret_cast<VkImage *>(pSwapchainImages))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename ImageAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<Image, ImageAllocator>>::type | |
| Device::getSwapchainImagesKHR(VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| std::vector<Image, ImageAllocator> swapchainImages; | |
| uint32_t swapchainImageCount; | |
| Result result; | |
| do | |
| { | |
| result = static_cast<Result>(d.vkGetSwapchainImagesKHR(m_device, static_cast<VkSwapchainKHR>(swapchain), &swapchainImageCount, nullptr)); | |
| if((result == Result::eSuccess) && swapchainImageCount) | |
| { | |
| swapchainImages.resize(swapchainImageCount); | |
| result = static_cast<Result>(d.vkGetSwapchainImagesKHR( | |
| m_device, static_cast<VkSwapchainKHR>(swapchain), &swapchainImageCount, reinterpret_cast<VkImage *>(swapchainImages.data()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(swapchainImageCount <= swapchainImages.size()); | |
| if(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()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(swapchainImageCount <= swapchainImages.size()); | |
| if(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; | |
| VkResult result = d.vkAcquireNextImageKHR( | |
| m_device, static_cast<VkSwapchainKHR>(swapchain), timeout, static_cast<VkSemaphore>(semaphore), static_cast<VkFence>(fence), &imageIndex); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::acquireNextImageKHR", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, | |
| VULKAN_HPP_NAMESPACE::Result::eTimeout, | |
| VULKAN_HPP_NAMESPACE::Result::eNotReady, | |
| VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR }); | |
| return ResultValue<uint32_t>(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), imageIndex); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Queue::presentKHR(const VULKAN_HPP_NAMESPACE::PresentInfoKHR *pPresentInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkQueuePresentKHR(m_queue, reinterpret_cast<const VkPresentInfoKHR *>(pPresentInfo))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result Queue::presentKHR(const VULKAN_HPP_NAMESPACE::PresentInfoKHR &presentInfo, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VkResult result = d.vkQueuePresentKHR(m_queue, reinterpret_cast<const VkPresentInfoKHR *>(&presentInfo)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), | |
| VULKAN_HPP_NAMESPACE_STRING "::Queue::presentKHR", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR }); | |
| return static_cast<VULKAN_HPP_NAMESPACE::Result>(result); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getGroupPresentCapabilitiesKHR( | |
| VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR *pDeviceGroupPresentCapabilities, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>( | |
| d.vkGetDeviceGroupPresentCapabilitiesKHR(m_device, reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHR *>(pDeviceGroupPresentCapabilities))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR>::type | |
| Device::getGroupPresentCapabilitiesKHR(Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR deviceGroupPresentCapabilities; | |
| VkResult result = | |
| d.vkGetDeviceGroupPresentCapabilitiesKHR(m_device, reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHR *>(&deviceGroupPresentCapabilities)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::getGroupPresentCapabilitiesKHR"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), deviceGroupPresentCapabilities); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getGroupSurfacePresentModesKHR(VULKAN_HPP_NAMESPACE::SurfaceKHR surface, | |
| VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR *pModes, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkGetDeviceGroupSurfacePresentModesKHR( | |
| m_device, static_cast<VkSurfaceKHR>(surface), reinterpret_cast<VkDeviceGroupPresentModeFlagsKHR *>(pModes))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR>::type | |
| Device::getGroupSurfacePresentModesKHR(VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR modes; | |
| VkResult result = d.vkGetDeviceGroupSurfacePresentModesKHR( | |
| m_device, static_cast<VkSurfaceKHR>(surface), reinterpret_cast<VkDeviceGroupPresentModeFlagsKHR *>(&modes)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::getGroupSurfacePresentModesKHR"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), modes); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getPresentRectanglesKHR(VULKAN_HPP_NAMESPACE::SurfaceKHR surface, | |
| uint32_t *pRectCount, | |
| VULKAN_HPP_NAMESPACE::Rect2D *pRects, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>( | |
| d.vkGetPhysicalDevicePresentRectanglesKHR(m_physicalDevice, static_cast<VkSurfaceKHR>(surface), pRectCount, reinterpret_cast<VkRect2D *>(pRects))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Rect2DAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<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()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(rectCount <= rects.size()); | |
| if(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()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(rectCount <= rects.size()); | |
| if(rectCount < rects.size()) | |
| { | |
| rects.resize(rectCount); | |
| } | |
| } | |
| return createResultValue(result, rects, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getPresentRectanglesKHR"); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::acquireNextImage2KHR(const VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR *pAcquireInfo, | |
| uint32_t *pImageIndex, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkAcquireNextImage2KHR(m_device, reinterpret_cast<const VkAcquireNextImageInfoKHR *>(pAcquireInfo), pImageIndex)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<uint32_t> Device::acquireNextImage2KHR(const VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR &acquireInfo, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| uint32_t imageIndex; | |
| VkResult result = d.vkAcquireNextImage2KHR(m_device, reinterpret_cast<const VkAcquireNextImageInfoKHR *>(&acquireInfo), &imageIndex); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::acquireNextImage2KHR", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, | |
| VULKAN_HPP_NAMESPACE::Result::eTimeout, | |
| VULKAN_HPP_NAMESPACE::Result::eNotReady, | |
| VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR }); | |
| return ResultValue<uint32_t>(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), imageIndex); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_KHR_display === | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPropertiesKHR(uint32_t *pPropertyCount, | |
| VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR *pProperties, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>( | |
| d.vkGetPhysicalDeviceDisplayPropertiesKHR(m_physicalDevice, pPropertyCount, reinterpret_cast<VkDisplayPropertiesKHR *>(pProperties))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename DisplayPropertiesKHRAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<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()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(propertyCount <= properties.size()); | |
| if(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()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(propertyCount <= properties.size()); | |
| if(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()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(propertyCount <= properties.size()); | |
| if(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()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(propertyCount <= properties.size()); | |
| if(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()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(displayCount <= displays.size()); | |
| if(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()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(displayCount <= displays.size()); | |
| if(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()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(propertyCount <= properties.size()); | |
| if(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()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(propertyCount <= properties.size()); | |
| if(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 VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayModeKHR>::type | |
| PhysicalDevice::createDisplayModeKHR(VULKAN_HPP_NAMESPACE::DisplayKHR display, | |
| const VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::DisplayModeKHR mode; | |
| VkResult 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)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::createDisplayModeKHR"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), mode); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayModeKHR, Dispatch>>::type | |
| PhysicalDevice::createDisplayModeKHRUnique(VULKAN_HPP_NAMESPACE::DisplayKHR display, | |
| const VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| 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 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; | |
| VkResult result = d.vkGetDisplayPlaneCapabilitiesKHR( | |
| m_physicalDevice, static_cast<VkDisplayModeKHR>(mode), planeIndex, reinterpret_cast<VkDisplayPlaneCapabilitiesKHR *>(&capabilities)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneCapabilitiesKHR"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), capabilities); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createDisplayPlaneSurfaceKHR(const VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR *pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| VULKAN_HPP_NAMESPACE::SurfaceKHR *pSurface, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkCreateDisplayPlaneSurfaceKHR(m_instance, | |
| reinterpret_cast<const VkDisplaySurfaceCreateInfoKHR *>(pCreateInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(pAllocator), | |
| reinterpret_cast<VkSurfaceKHR *>(pSurface))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type | |
| Instance::createDisplayPlaneSurfaceKHR(const VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface; | |
| VkResult 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)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Instance::createDisplayPlaneSurfaceKHR"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), surface); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type | |
| Instance::createDisplayPlaneSurfaceKHRUnique(const VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| 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 VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SwapchainKHR, SwapchainKHRAllocator>>::type | |
| Device::createSharedSwapchainsKHR(ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const &createInfos, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| std::vector<VULKAN_HPP_NAMESPACE::SwapchainKHR, SwapchainKHRAllocator> swapchains(createInfos.size()); | |
| VkResult 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())); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHR"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), swapchains); | |
| } | |
| 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 VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SwapchainKHR, SwapchainKHRAllocator>>::type | |
| Device::createSharedSwapchainsKHR(ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const &createInfos, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| SwapchainKHRAllocator &swapchainKHRAllocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| std::vector<VULKAN_HPP_NAMESPACE::SwapchainKHR, SwapchainKHRAllocator> swapchains(createInfos.size(), swapchainKHRAllocator); | |
| VkResult 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())); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHR"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), swapchains); | |
| } | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::SwapchainKHR>::type | |
| Device::createSharedSwapchainKHR(const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain; | |
| VkResult 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)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainKHR"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), swapchain); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch, typename SwapchainKHRAllocator> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<SwapchainKHR, Dispatch>, SwapchainKHRAllocator>>::type | |
| Device::createSharedSwapchainsKHRUnique(ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const &createInfos, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| std::vector<UniqueHandle<SwapchainKHR, Dispatch>, SwapchainKHRAllocator> uniqueSwapchains; | |
| std::vector<SwapchainKHR> swapchains(createInfos.size()); | |
| Result result = static_cast<Result>(d.vkCreateSharedSwapchainsKHR( | |
| m_device, | |
| createInfos.size(), | |
| reinterpret_cast<const VkSwapchainCreateInfoKHR *>(createInfos.data()), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)), | |
| reinterpret_cast<VkSwapchainKHR *>(swapchains.data()))); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| uniqueSwapchains.reserve(createInfos.size()); | |
| ObjectDestroy<Device, Dispatch> deleter(*this, allocator, d); | |
| for(size_t i = 0; i < createInfos.size(); i++) | |
| { | |
| uniqueSwapchains.push_back(UniqueHandle<SwapchainKHR, Dispatch>(swapchains[i], deleter)); | |
| } | |
| } | |
| return createResultValue(result, std::move(uniqueSwapchains), VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHRUnique"); | |
| } | |
| template<typename Dispatch, | |
| typename SwapchainKHRAllocator, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<SwapchainKHR, Dispatch>>::value, int>::type> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<SwapchainKHR, Dispatch>, SwapchainKHRAllocator>>::type | |
| Device::createSharedSwapchainsKHRUnique(ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const &createInfos, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| SwapchainKHRAllocator &swapchainKHRAllocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| std::vector<UniqueHandle<SwapchainKHR, Dispatch>, SwapchainKHRAllocator> uniqueSwapchains(swapchainKHRAllocator); | |
| std::vector<SwapchainKHR> swapchains(createInfos.size()); | |
| Result result = static_cast<Result>(d.vkCreateSharedSwapchainsKHR( | |
| m_device, | |
| createInfos.size(), | |
| reinterpret_cast<const VkSwapchainCreateInfoKHR *>(createInfos.data()), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)), | |
| reinterpret_cast<VkSwapchainKHR *>(swapchains.data()))); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| uniqueSwapchains.reserve(createInfos.size()); | |
| ObjectDestroy<Device, Dispatch> deleter(*this, allocator, d); | |
| for(size_t i = 0; i < createInfos.size(); i++) | |
| { | |
| uniqueSwapchains.push_back(UniqueHandle<SwapchainKHR, Dispatch>(swapchains[i], deleter)); | |
| } | |
| } | |
| return createResultValue(result, std::move(uniqueSwapchains), VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHRUnique"); | |
| } | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SwapchainKHR, Dispatch>>::type | |
| Device::createSharedSwapchainKHRUnique(const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| SwapchainKHR swapchain; | |
| Result result = static_cast<Result>(d.vkCreateSharedSwapchainsKHR( | |
| m_device, | |
| 1, | |
| reinterpret_cast<const VkSwapchainCreateInfoKHR *>(&createInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)), | |
| reinterpret_cast<VkSwapchainKHR *>(&swapchain))); | |
| ObjectDestroy<Device, Dispatch> deleter(*this, allocator, d); | |
| return createResultValue<SwapchainKHR, Dispatch>(result, swapchain, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainKHRUnique", deleter); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #if defined(VK_USE_PLATFORM_XLIB_KHR) | |
| //=== VK_KHR_xlib_surface === | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createXlibSurfaceKHR(const VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR *pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| VULKAN_HPP_NAMESPACE::SurfaceKHR *pSurface, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkCreateXlibSurfaceKHR(m_instance, | |
| reinterpret_cast<const VkXlibSurfaceCreateInfoKHR *>(pCreateInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(pAllocator), | |
| reinterpret_cast<VkSurfaceKHR *>(pSurface))); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type | |
| Instance::createXlibSurfaceKHR(const VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface; | |
| VkResult 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)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Instance::createXlibSurfaceKHR"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), surface); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type | |
| Instance::createXlibSurfaceKHRUnique(const VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| 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 VULKAN_HPP_NAMESPACE::Bool32 | |
| PhysicalDevice::getXlibPresentationSupportKHR(uint32_t queueFamilyIndex, Display &dpy, VisualID visualID, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VkBool32 result = d.vkGetPhysicalDeviceXlibPresentationSupportKHR(m_physicalDevice, queueFamilyIndex, &dpy, visualID); | |
| return static_cast<VULKAN_HPP_NAMESPACE::Bool32>(result); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #endif /*VK_USE_PLATFORM_XLIB_KHR*/ | |
| #if defined(VK_USE_PLATFORM_XCB_KHR) | |
| //=== VK_KHR_xcb_surface === | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createXcbSurfaceKHR(const VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR *pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| VULKAN_HPP_NAMESPACE::SurfaceKHR *pSurface, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkCreateXcbSurfaceKHR(m_instance, | |
| reinterpret_cast<const VkXcbSurfaceCreateInfoKHR *>(pCreateInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(pAllocator), | |
| reinterpret_cast<VkSurfaceKHR *>(pSurface))); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type | |
| Instance::createXcbSurfaceKHR(const VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface; | |
| VkResult 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)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Instance::createXcbSurfaceKHR"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), surface); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type | |
| Instance::createXcbSurfaceKHRUnique(const VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| 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 VULKAN_HPP_NAMESPACE::Bool32 PhysicalDevice::getXcbPresentationSupportKHR(uint32_t queueFamilyIndex, | |
| xcb_connection_t &connection, | |
| xcb_visualid_t visual_id, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VkBool32 result = d.vkGetPhysicalDeviceXcbPresentationSupportKHR(m_physicalDevice, queueFamilyIndex, &connection, visual_id); | |
| return static_cast<VULKAN_HPP_NAMESPACE::Bool32>(result); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #endif /*VK_USE_PLATFORM_XCB_KHR*/ | |
| #if defined(VK_USE_PLATFORM_WAYLAND_KHR) | |
| //=== VK_KHR_wayland_surface === | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createWaylandSurfaceKHR(const VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR *pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| VULKAN_HPP_NAMESPACE::SurfaceKHR *pSurface, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkCreateWaylandSurfaceKHR(m_instance, | |
| reinterpret_cast<const VkWaylandSurfaceCreateInfoKHR *>(pCreateInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(pAllocator), | |
| reinterpret_cast<VkSurfaceKHR *>(pSurface))); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type | |
| Instance::createWaylandSurfaceKHR(const VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface; | |
| VkResult 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)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Instance::createWaylandSurfaceKHR"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), surface); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type | |
| Instance::createWaylandSurfaceKHRUnique(const VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| 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 VULKAN_HPP_NAMESPACE::Bool32 | |
| PhysicalDevice::getWaylandPresentationSupportKHR(uint32_t queueFamilyIndex, struct wl_display &display, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VkBool32 result = d.vkGetPhysicalDeviceWaylandPresentationSupportKHR(m_physicalDevice, queueFamilyIndex, &display); | |
| return static_cast<VULKAN_HPP_NAMESPACE::Bool32>(result); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ | |
| #if defined(VK_USE_PLATFORM_ANDROID_KHR) | |
| //=== VK_KHR_android_surface === | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createAndroidSurfaceKHR(const VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR *pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| VULKAN_HPP_NAMESPACE::SurfaceKHR *pSurface, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkCreateAndroidSurfaceKHR(m_instance, | |
| reinterpret_cast<const VkAndroidSurfaceCreateInfoKHR *>(pCreateInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(pAllocator), | |
| reinterpret_cast<VkSurfaceKHR *>(pSurface))); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type | |
| Instance::createAndroidSurfaceKHR(const VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface; | |
| VkResult 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)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Instance::createAndroidSurfaceKHR"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), surface); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type | |
| Instance::createAndroidSurfaceKHRUnique(const VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| 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 VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type | |
| Instance::createWin32SurfaceKHR(const VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface; | |
| VkResult 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)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Instance::createWin32SurfaceKHR"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), surface); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type | |
| Instance::createWin32SurfaceKHRUnique(const VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| 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_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT>::type | |
| Instance::createDebugReportCallbackEXT(const VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback; | |
| VkResult 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)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Instance::createDebugReportCallbackEXT"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), callback); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT, Dispatch>>::type | |
| Instance::createDebugReportCallbackEXTUnique(const VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback; | |
| Result result = static_cast<Result>(d.vkCreateDebugReportCallbackEXT( | |
| m_instance, | |
| reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT *>(&createInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)), | |
| reinterpret_cast<VkDebugReportCallbackEXT *>(&callback))); | |
| ObjectDestroy<Instance, Dispatch> deleter(*this, allocator, d); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT, Dispatch>( | |
| result, callback, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDebugReportCallbackEXTUnique", deleter); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Instance::destroyDebugReportCallbackEXT(VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyDebugReportCallbackEXT( | |
| m_instance, static_cast<VkDebugReportCallbackEXT>(callback), reinterpret_cast<const VkAllocationCallbacks *>(pAllocator)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Instance::destroyDebugReportCallbackEXT(VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyDebugReportCallbackEXT( | |
| m_instance, | |
| static_cast<VkDebugReportCallbackEXT>(callback), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Instance::destroy(VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyDebugReportCallbackEXT( | |
| m_instance, static_cast<VkDebugReportCallbackEXT>(callback), reinterpret_cast<const VkAllocationCallbacks *>(pAllocator)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Instance::destroy(VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyDebugReportCallbackEXT( | |
| m_instance, | |
| static_cast<VkDebugReportCallbackEXT>(callback), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Instance::debugReportMessageEXT(VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT flags, | |
| VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType, | |
| uint64_t object, | |
| size_t location, | |
| int32_t messageCode, | |
| const char *pLayerPrefix, | |
| const char *pMessage, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDebugReportMessageEXT(m_instance, | |
| static_cast<VkDebugReportFlagsEXT>(flags), | |
| static_cast<VkDebugReportObjectTypeEXT>(objectType), | |
| object, | |
| location, | |
| messageCode, | |
| pLayerPrefix, | |
| pMessage); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Instance::debugReportMessageEXT(VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT flags, | |
| VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType, | |
| uint64_t object, | |
| size_t location, | |
| int32_t messageCode, | |
| const std::string &layerPrefix, | |
| const std::string &message, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDebugReportMessageEXT(m_instance, | |
| static_cast<VkDebugReportFlagsEXT>(flags), | |
| static_cast<VkDebugReportObjectTypeEXT>(objectType), | |
| object, | |
| location, | |
| messageCode, | |
| layerPrefix.c_str(), | |
| message.c_str()); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_EXT_debug_marker === | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::debugMarkerSetObjectTagEXT(const VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT *pTagInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkDebugMarkerSetObjectTagEXT(m_device, reinterpret_cast<const VkDebugMarkerObjectTagInfoEXT *>(pTagInfo))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| Device::debugMarkerSetObjectTagEXT(const VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT &tagInfo, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VkResult result = d.vkDebugMarkerSetObjectTagEXT(m_device, reinterpret_cast<const VkDebugMarkerObjectTagInfoEXT *>(&tagInfo)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::debugMarkerSetObjectTagEXT"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::debugMarkerSetObjectNameEXT(const VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT *pNameInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkDebugMarkerSetObjectNameEXT(m_device, reinterpret_cast<const VkDebugMarkerObjectNameInfoEXT *>(pNameInfo))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| Device::debugMarkerSetObjectNameEXT(const VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT &nameInfo, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VkResult result = d.vkDebugMarkerSetObjectNameEXT(m_device, reinterpret_cast<const VkDebugMarkerObjectNameInfoEXT *>(&nameInfo)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::debugMarkerSetObjectNameEXT"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::debugMarkerBeginEXT(const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT *pMarkerInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdDebugMarkerBeginEXT(m_commandBuffer, reinterpret_cast<const VkDebugMarkerMarkerInfoEXT *>(pMarkerInfo)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::debugMarkerBeginEXT(const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT &markerInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdDebugMarkerBeginEXT(m_commandBuffer, reinterpret_cast<const VkDebugMarkerMarkerInfoEXT *>(&markerInfo)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::debugMarkerEndEXT(Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdDebugMarkerEndEXT(m_commandBuffer); | |
| } | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::debugMarkerInsertEXT(const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT *pMarkerInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdDebugMarkerInsertEXT(m_commandBuffer, reinterpret_cast<const VkDebugMarkerMarkerInfoEXT *>(pMarkerInfo)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::debugMarkerInsertEXT(const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT &markerInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdDebugMarkerInsertEXT(m_commandBuffer, reinterpret_cast<const VkDebugMarkerMarkerInfoEXT *>(&markerInfo)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #if defined(VK_ENABLE_BETA_EXTENSIONS) | |
| //=== VK_KHR_video_queue === | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getVideoCapabilitiesKHR(const VULKAN_HPP_NAMESPACE::VideoProfileKHR *pVideoProfile, | |
| VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR *pCapabilities, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkGetPhysicalDeviceVideoCapabilitiesKHR( | |
| m_physicalDevice, reinterpret_cast<const VkVideoProfileKHR *>(pVideoProfile), reinterpret_cast<VkVideoCapabilitiesKHR *>(pCapabilities))); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR>::type | |
| PhysicalDevice::getVideoCapabilitiesKHR(const VULKAN_HPP_NAMESPACE::VideoProfileKHR &videoProfile, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR capabilities; | |
| VkResult result = d.vkGetPhysicalDeviceVideoCapabilitiesKHR( | |
| m_physicalDevice, reinterpret_cast<const VkVideoProfileKHR *>(&videoProfile), reinterpret_cast<VkVideoCapabilitiesKHR *>(&capabilities)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoCapabilitiesKHR"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), capabilities); | |
| } | |
| template<typename X, typename Y, typename... Z, typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<StructureChain<X, Y, Z...>>::type | |
| PhysicalDevice::getVideoCapabilitiesKHR(const VULKAN_HPP_NAMESPACE::VideoProfileKHR &videoProfile, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| StructureChain<X, Y, Z...> structureChain; | |
| VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR &capabilities = structureChain.template get<VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR>(); | |
| Result result = static_cast<Result>(d.vkGetPhysicalDeviceVideoCapabilitiesKHR( | |
| m_physicalDevice, reinterpret_cast<const VkVideoProfileKHR *>(&videoProfile), reinterpret_cast<VkVideoCapabilitiesKHR *>(&capabilities))); | |
| return createResultValue(result, structureChain, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoCapabilitiesKHR"); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| PhysicalDevice::getVideoFormatPropertiesKHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR *pVideoFormatInfo, | |
| uint32_t *pVideoFormatPropertyCount, | |
| VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR *pVideoFormatProperties, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkGetPhysicalDeviceVideoFormatPropertiesKHR(m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceVideoFormatInfoKHR *>(pVideoFormatInfo), | |
| pVideoFormatPropertyCount, | |
| reinterpret_cast<VkVideoFormatPropertiesKHR *>(pVideoFormatProperties))); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename VideoFormatPropertiesKHRAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VideoFormatPropertiesKHR, VideoFormatPropertiesKHRAllocator>>::type | |
| PhysicalDevice::getVideoFormatPropertiesKHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR &videoFormatInfo, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| std::vector<VideoFormatPropertiesKHR, VideoFormatPropertiesKHRAllocator> videoFormatProperties; | |
| uint32_t videoFormatPropertyCount; | |
| Result result; | |
| do | |
| { | |
| result = static_cast<Result>(d.vkGetPhysicalDeviceVideoFormatPropertiesKHR( | |
| m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceVideoFormatInfoKHR *>(&videoFormatInfo), &videoFormatPropertyCount, nullptr)); | |
| if((result == Result::eSuccess) && videoFormatPropertyCount) | |
| { | |
| videoFormatProperties.resize(videoFormatPropertyCount); | |
| result = static_cast<Result>( | |
| d.vkGetPhysicalDeviceVideoFormatPropertiesKHR(m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceVideoFormatInfoKHR *>(&videoFormatInfo), | |
| &videoFormatPropertyCount, | |
| reinterpret_cast<VkVideoFormatPropertiesKHR *>(videoFormatProperties.data()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(videoFormatPropertyCount <= videoFormatProperties.size()); | |
| if(videoFormatPropertyCount < videoFormatProperties.size()) | |
| { | |
| videoFormatProperties.resize(videoFormatPropertyCount); | |
| } | |
| } | |
| return createResultValue(result, videoFormatProperties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoFormatPropertiesKHR"); | |
| } | |
| template<typename VideoFormatPropertiesKHRAllocator, | |
| typename Dispatch, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, VideoFormatPropertiesKHR>::value, int>::type> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VideoFormatPropertiesKHR, VideoFormatPropertiesKHRAllocator>>::type | |
| PhysicalDevice::getVideoFormatPropertiesKHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR &videoFormatInfo, | |
| VideoFormatPropertiesKHRAllocator &videoFormatPropertiesKHRAllocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| std::vector<VideoFormatPropertiesKHR, VideoFormatPropertiesKHRAllocator> videoFormatProperties(videoFormatPropertiesKHRAllocator); | |
| uint32_t videoFormatPropertyCount; | |
| Result result; | |
| do | |
| { | |
| result = static_cast<Result>(d.vkGetPhysicalDeviceVideoFormatPropertiesKHR( | |
| m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceVideoFormatInfoKHR *>(&videoFormatInfo), &videoFormatPropertyCount, nullptr)); | |
| if((result == Result::eSuccess) && videoFormatPropertyCount) | |
| { | |
| videoFormatProperties.resize(videoFormatPropertyCount); | |
| result = static_cast<Result>( | |
| d.vkGetPhysicalDeviceVideoFormatPropertiesKHR(m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceVideoFormatInfoKHR *>(&videoFormatInfo), | |
| &videoFormatPropertyCount, | |
| reinterpret_cast<VkVideoFormatPropertiesKHR *>(videoFormatProperties.data()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(videoFormatPropertyCount <= videoFormatProperties.size()); | |
| if(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 VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::VideoSessionKHR>::type | |
| Device::createVideoSessionKHR(const VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession; | |
| VkResult 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)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::createVideoSessionKHR"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), videoSession); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::VideoSessionKHR, Dispatch>>::type | |
| Device::createVideoSessionKHRUnique(const VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession; | |
| Result result = static_cast<Result>( | |
| d.vkCreateVideoSessionKHR(m_device, | |
| reinterpret_cast<const VkVideoSessionCreateInfoKHR *>(&createInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)), | |
| reinterpret_cast<VkVideoSessionKHR *>(&videoSession))); | |
| ObjectDestroy<Device, Dispatch> deleter(*this, allocator, d); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::VideoSessionKHR, Dispatch>( | |
| result, videoSession, VULKAN_HPP_NAMESPACE_STRING "::Device::createVideoSessionKHRUnique", deleter); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroyVideoSessionKHR(VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyVideoSessionKHR(m_device, static_cast<VkVideoSessionKHR>(videoSession), reinterpret_cast<const VkAllocationCallbacks *>(pAllocator)); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroyVideoSessionKHR(VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyVideoSessionKHR( | |
| m_device, | |
| static_cast<VkVideoSessionKHR>(videoSession), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy(VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyVideoSessionKHR(m_device, static_cast<VkVideoSessionKHR>(videoSession), reinterpret_cast<const VkAllocationCallbacks *>(pAllocator)); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy(VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyVideoSessionKHR( | |
| m_device, | |
| static_cast<VkVideoSessionKHR>(videoSession), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::getVideoSessionMemoryRequirementsKHR(VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession, | |
| uint32_t *pVideoSessionMemoryRequirementsCount, | |
| VULKAN_HPP_NAMESPACE::VideoGetMemoryPropertiesKHR *pVideoSessionMemoryRequirements, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>( | |
| d.vkGetVideoSessionMemoryRequirementsKHR(m_device, | |
| static_cast<VkVideoSessionKHR>(videoSession), | |
| pVideoSessionMemoryRequirementsCount, | |
| reinterpret_cast<VkVideoGetMemoryPropertiesKHR *>(pVideoSessionMemoryRequirements))); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename VideoGetMemoryPropertiesKHRAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VideoGetMemoryPropertiesKHR, VideoGetMemoryPropertiesKHRAllocator>>::type | |
| Device::getVideoSessionMemoryRequirementsKHR(VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| std::vector<VideoGetMemoryPropertiesKHR, VideoGetMemoryPropertiesKHRAllocator> videoSessionMemoryRequirements; | |
| uint32_t videoSessionMemoryRequirementsCount; | |
| Result result; | |
| do | |
| { | |
| result = static_cast<Result>( | |
| d.vkGetVideoSessionMemoryRequirementsKHR(m_device, static_cast<VkVideoSessionKHR>(videoSession), &videoSessionMemoryRequirementsCount, nullptr)); | |
| if((result == Result::eSuccess) && videoSessionMemoryRequirementsCount) | |
| { | |
| videoSessionMemoryRequirements.resize(videoSessionMemoryRequirementsCount); | |
| result = static_cast<Result>( | |
| d.vkGetVideoSessionMemoryRequirementsKHR(m_device, | |
| static_cast<VkVideoSessionKHR>(videoSession), | |
| &videoSessionMemoryRequirementsCount, | |
| reinterpret_cast<VkVideoGetMemoryPropertiesKHR *>(videoSessionMemoryRequirements.data()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(videoSessionMemoryRequirementsCount <= videoSessionMemoryRequirements.size()); | |
| if(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()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(videoSessionMemoryRequirementsCount <= videoSessionMemoryRequirements.size()); | |
| if(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); | |
| VkResult result = d.vkBindVideoSessionMemoryKHR(m_device, | |
| static_cast<VkVideoSessionKHR>(videoSession), | |
| videoSessionBindMemories.size(), | |
| reinterpret_cast<const VkVideoBindMemoryKHR *>(videoSessionBindMemories.data())); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::bindVideoSessionMemoryKHR"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result)); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::createVideoSessionParametersKHR(const VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR *pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR *pVideoSessionParameters, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkCreateVideoSessionParametersKHR(m_device, | |
| reinterpret_cast<const VkVideoSessionParametersCreateInfoKHR *>(pCreateInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(pAllocator), | |
| reinterpret_cast<VkVideoSessionParametersKHR *>(pVideoSessionParameters))); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR>::type | |
| Device::createVideoSessionParametersKHR(const VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters; | |
| VkResult 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)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::createVideoSessionParametersKHR"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), videoSessionParameters); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR, Dispatch>>::type | |
| Device::createVideoSessionParametersKHRUnique(const VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters; | |
| Result result = static_cast<Result>(d.vkCreateVideoSessionParametersKHR( | |
| m_device, | |
| reinterpret_cast<const VkVideoSessionParametersCreateInfoKHR *>(&createInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)), | |
| reinterpret_cast<VkVideoSessionParametersKHR *>(&videoSessionParameters))); | |
| ObjectDestroy<Device, Dispatch> deleter(*this, allocator, d); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR, Dispatch>( | |
| result, videoSessionParameters, VULKAN_HPP_NAMESPACE_STRING "::Device::createVideoSessionParametersKHRUnique", deleter); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::updateVideoSessionParametersKHR(VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters, | |
| const VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR *pUpdateInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkUpdateVideoSessionParametersKHR(m_device, | |
| static_cast<VkVideoSessionParametersKHR>(videoSessionParameters), | |
| reinterpret_cast<const VkVideoSessionParametersUpdateInfoKHR *>(pUpdateInfo))); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| Device::updateVideoSessionParametersKHR(VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters, | |
| const VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR &updateInfo, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VkResult result = d.vkUpdateVideoSessionParametersKHR(m_device, | |
| static_cast<VkVideoSessionParametersKHR>(videoSessionParameters), | |
| reinterpret_cast<const VkVideoSessionParametersUpdateInfoKHR *>(&updateInfo)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::updateVideoSessionParametersKHR"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result)); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroyVideoSessionParametersKHR(VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyVideoSessionParametersKHR( | |
| m_device, static_cast<VkVideoSessionParametersKHR>(videoSessionParameters), reinterpret_cast<const VkAllocationCallbacks *>(pAllocator)); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroyVideoSessionParametersKHR(VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyVideoSessionParametersKHR( | |
| m_device, | |
| static_cast<VkVideoSessionParametersKHR>(videoSessionParameters), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy(VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyVideoSessionParametersKHR( | |
| m_device, static_cast<VkVideoSessionParametersKHR>(videoSessionParameters), reinterpret_cast<const VkAllocationCallbacks *>(pAllocator)); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy(VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyVideoSessionParametersKHR( | |
| m_device, | |
| static_cast<VkVideoSessionParametersKHR>(videoSessionParameters), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::beginVideoCodingKHR(const VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR *pBeginInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdBeginVideoCodingKHR(m_commandBuffer, reinterpret_cast<const VkVideoBeginCodingInfoKHR *>(pBeginInfo)); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::beginVideoCodingKHR(const VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR &beginInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdBeginVideoCodingKHR(m_commandBuffer, reinterpret_cast<const VkVideoBeginCodingInfoKHR *>(&beginInfo)); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::endVideoCodingKHR(const VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR *pEndCodingInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdEndVideoCodingKHR(m_commandBuffer, reinterpret_cast<const VkVideoEndCodingInfoKHR *>(pEndCodingInfo)); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::endVideoCodingKHR(const VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR &endCodingInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdEndVideoCodingKHR(m_commandBuffer, reinterpret_cast<const VkVideoEndCodingInfoKHR *>(&endCodingInfo)); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::controlVideoCodingKHR(const VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR *pCodingControlInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdControlVideoCodingKHR(m_commandBuffer, reinterpret_cast<const VkVideoCodingControlInfoKHR *>(pCodingControlInfo)); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::controlVideoCodingKHR(const VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR &codingControlInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdControlVideoCodingKHR(m_commandBuffer, reinterpret_cast<const VkVideoCodingControlInfoKHR *>(&codingControlInfo)); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #endif /*VK_ENABLE_BETA_EXTENSIONS*/ | |
| #if defined(VK_ENABLE_BETA_EXTENSIONS) | |
| //=== VK_KHR_video_decode_queue === | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::decodeVideoKHR(const VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR *pFrameInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdDecodeVideoKHR(m_commandBuffer, reinterpret_cast<const VkVideoDecodeInfoKHR *>(pFrameInfo)); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::decodeVideoKHR(const VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR &frameInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdDecodeVideoKHR(m_commandBuffer, reinterpret_cast<const VkVideoDecodeInfoKHR *>(&frameInfo)); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #endif /*VK_ENABLE_BETA_EXTENSIONS*/ | |
| //=== VK_EXT_transform_feedback === | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::bindTransformFeedbackBuffersEXT(uint32_t firstBinding, | |
| uint32_t bindingCount, | |
| const VULKAN_HPP_NAMESPACE::Buffer *pBuffers, | |
| const VULKAN_HPP_NAMESPACE::DeviceSize *pOffsets, | |
| const VULKAN_HPP_NAMESPACE::DeviceSize *pSizes, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdBindTransformFeedbackBuffersEXT(m_commandBuffer, | |
| firstBinding, | |
| bindingCount, | |
| reinterpret_cast<const VkBuffer *>(pBuffers), | |
| reinterpret_cast<const VkDeviceSize *>(pOffsets), | |
| reinterpret_cast<const VkDeviceSize *>(pSizes)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::bindTransformFeedbackBuffersEXT(uint32_t firstBinding, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &buffers, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const &offsets, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const &sizes, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| # ifdef VULKAN_HPP_NO_EXCEPTIONS | |
| VULKAN_HPP_ASSERT(buffers.size() == offsets.size()); | |
| VULKAN_HPP_ASSERT(sizes.empty() || buffers.size() == sizes.size()); | |
| # else | |
| if(buffers.size() != offsets.size()) | |
| { | |
| throw LogicError(VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindTransformFeedbackBuffersEXT: buffers.size() != offsets.size()"); | |
| } | |
| if(!sizes.empty() && buffers.size() != sizes.size()) | |
| { | |
| throw LogicError(VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindTransformFeedbackBuffersEXT: buffers.size() != sizes.size()"); | |
| } | |
| # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ | |
| d.vkCmdBindTransformFeedbackBuffersEXT(m_commandBuffer, | |
| firstBinding, | |
| buffers.size(), | |
| reinterpret_cast<const VkBuffer *>(buffers.data()), | |
| reinterpret_cast<const VkDeviceSize *>(offsets.data()), | |
| reinterpret_cast<const VkDeviceSize *>(sizes.data())); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::beginTransformFeedbackEXT(uint32_t firstCounterBuffer, | |
| uint32_t counterBufferCount, | |
| const VULKAN_HPP_NAMESPACE::Buffer *pCounterBuffers, | |
| const VULKAN_HPP_NAMESPACE::DeviceSize *pCounterBufferOffsets, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdBeginTransformFeedbackEXT(m_commandBuffer, | |
| firstCounterBuffer, | |
| counterBufferCount, | |
| reinterpret_cast<const VkBuffer *>(pCounterBuffers), | |
| reinterpret_cast<const VkDeviceSize *>(pCounterBufferOffsets)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::beginTransformFeedbackEXT(uint32_t firstCounterBuffer, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &counterBuffers, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const &counterBufferOffsets, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| # ifdef VULKAN_HPP_NO_EXCEPTIONS | |
| VULKAN_HPP_ASSERT(counterBufferOffsets.empty() || counterBuffers.size() == counterBufferOffsets.size()); | |
| # else | |
| if(!counterBufferOffsets.empty() && counterBuffers.size() != counterBufferOffsets.size()) | |
| { | |
| throw LogicError(VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::beginTransformFeedbackEXT: counterBuffers.size() != counterBufferOffsets.size()"); | |
| } | |
| # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ | |
| d.vkCmdBeginTransformFeedbackEXT(m_commandBuffer, | |
| firstCounterBuffer, | |
| counterBuffers.size(), | |
| reinterpret_cast<const VkBuffer *>(counterBuffers.data()), | |
| reinterpret_cast<const VkDeviceSize *>(counterBufferOffsets.data())); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::endTransformFeedbackEXT(uint32_t firstCounterBuffer, | |
| uint32_t counterBufferCount, | |
| const VULKAN_HPP_NAMESPACE::Buffer *pCounterBuffers, | |
| const VULKAN_HPP_NAMESPACE::DeviceSize *pCounterBufferOffsets, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdEndTransformFeedbackEXT(m_commandBuffer, | |
| firstCounterBuffer, | |
| counterBufferCount, | |
| reinterpret_cast<const VkBuffer *>(pCounterBuffers), | |
| reinterpret_cast<const VkDeviceSize *>(pCounterBufferOffsets)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::endTransformFeedbackEXT(uint32_t firstCounterBuffer, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &counterBuffers, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const &counterBufferOffsets, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| # ifdef VULKAN_HPP_NO_EXCEPTIONS | |
| VULKAN_HPP_ASSERT(counterBufferOffsets.empty() || counterBuffers.size() == counterBufferOffsets.size()); | |
| # else | |
| if(!counterBufferOffsets.empty() && counterBuffers.size() != counterBufferOffsets.size()) | |
| { | |
| throw LogicError(VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::endTransformFeedbackEXT: counterBuffers.size() != counterBufferOffsets.size()"); | |
| } | |
| # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ | |
| d.vkCmdEndTransformFeedbackEXT(m_commandBuffer, | |
| firstCounterBuffer, | |
| counterBuffers.size(), | |
| reinterpret_cast<const VkBuffer *>(counterBuffers.data()), | |
| reinterpret_cast<const VkDeviceSize *>(counterBufferOffsets.data())); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::beginQueryIndexedEXT(VULKAN_HPP_NAMESPACE::QueryPool queryPool, | |
| uint32_t query, | |
| VULKAN_HPP_NAMESPACE::QueryControlFlags flags, | |
| uint32_t index, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdBeginQueryIndexedEXT(m_commandBuffer, static_cast<VkQueryPool>(queryPool), query, static_cast<VkQueryControlFlags>(flags), index); | |
| } | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::endQueryIndexedEXT(VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query, uint32_t index, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdEndQueryIndexedEXT(m_commandBuffer, static_cast<VkQueryPool>(queryPool), query, index); | |
| } | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::drawIndirectByteCountEXT(uint32_t instanceCount, | |
| uint32_t firstInstance, | |
| VULKAN_HPP_NAMESPACE::Buffer counterBuffer, | |
| VULKAN_HPP_NAMESPACE::DeviceSize counterBufferOffset, | |
| uint32_t counterOffset, | |
| uint32_t vertexStride, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdDrawIndirectByteCountEXT(m_commandBuffer, | |
| instanceCount, | |
| firstInstance, | |
| static_cast<VkBuffer>(counterBuffer), | |
| static_cast<VkDeviceSize>(counterBufferOffset), | |
| counterOffset, | |
| vertexStride); | |
| } | |
| //=== VK_NVX_binary_import === | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createCuModuleNVX(const VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX *pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| VULKAN_HPP_NAMESPACE::CuModuleNVX *pModule, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkCreateCuModuleNVX(m_device, | |
| reinterpret_cast<const VkCuModuleCreateInfoNVX *>(pCreateInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(pAllocator), | |
| reinterpret_cast<VkCuModuleNVX *>(pModule))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::CuModuleNVX>::type | |
| Device::createCuModuleNVX(const VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::CuModuleNVX module; | |
| VkResult 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)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::createCuModuleNVX"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), module); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CuModuleNVX, Dispatch>>::type | |
| Device::createCuModuleNVXUnique(const VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| 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 VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::CuFunctionNVX>::type | |
| Device::createCuFunctionNVX(const VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::CuFunctionNVX function; | |
| VkResult 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)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::createCuFunctionNVX"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), function); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CuFunctionNVX, Dispatch>>::type | |
| Device::createCuFunctionNVXUnique(const VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::CuFunctionNVX function; | |
| Result result = static_cast<Result>( | |
| d.vkCreateCuFunctionNVX(m_device, | |
| reinterpret_cast<const VkCuFunctionCreateInfoNVX *>(&createInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)), | |
| reinterpret_cast<VkCuFunctionNVX *>(&function))); | |
| ObjectDestroy<Device, Dispatch> deleter(*this, allocator, d); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::CuFunctionNVX, Dispatch>( | |
| result, function, VULKAN_HPP_NAMESPACE_STRING "::Device::createCuFunctionNVXUnique", deleter); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroyCuModuleNVX(VULKAN_HPP_NAMESPACE::CuModuleNVX module, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyCuModuleNVX(m_device, static_cast<VkCuModuleNVX>(module), reinterpret_cast<const VkAllocationCallbacks *>(pAllocator)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroyCuModuleNVX(VULKAN_HPP_NAMESPACE::CuModuleNVX module, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyCuModuleNVX(m_device, | |
| static_cast<VkCuModuleNVX>(module), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy(VULKAN_HPP_NAMESPACE::CuModuleNVX module, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyCuModuleNVX(m_device, static_cast<VkCuModuleNVX>(module), reinterpret_cast<const VkAllocationCallbacks *>(pAllocator)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy(VULKAN_HPP_NAMESPACE::CuModuleNVX module, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyCuModuleNVX(m_device, | |
| static_cast<VkCuModuleNVX>(module), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroyCuFunctionNVX(VULKAN_HPP_NAMESPACE::CuFunctionNVX function, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyCuFunctionNVX(m_device, static_cast<VkCuFunctionNVX>(function), reinterpret_cast<const VkAllocationCallbacks *>(pAllocator)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroyCuFunctionNVX(VULKAN_HPP_NAMESPACE::CuFunctionNVX function, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyCuFunctionNVX(m_device, | |
| static_cast<VkCuFunctionNVX>(function), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy(VULKAN_HPP_NAMESPACE::CuFunctionNVX function, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyCuFunctionNVX(m_device, static_cast<VkCuFunctionNVX>(function), reinterpret_cast<const VkAllocationCallbacks *>(pAllocator)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy(VULKAN_HPP_NAMESPACE::CuFunctionNVX function, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyCuFunctionNVX(m_device, | |
| static_cast<VkCuFunctionNVX>(function), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::cuLaunchKernelNVX(const VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX *pLaunchInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdCuLaunchKernelNVX(m_commandBuffer, reinterpret_cast<const VkCuLaunchInfoNVX *>(pLaunchInfo)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::cuLaunchKernelNVX(const VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX &launchInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdCuLaunchKernelNVX(m_commandBuffer, reinterpret_cast<const VkCuLaunchInfoNVX *>(&launchInfo)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_NVX_image_view_handle === | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE uint32_t Device::getImageViewHandleNVX(const VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX *pInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return d.vkGetImageViewHandleNVX(m_device, reinterpret_cast<const VkImageViewHandleInfoNVX *>(pInfo)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE uint32_t Device::getImageViewHandleNVX(const VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX &info, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| uint32_t result = d.vkGetImageViewHandleNVX(m_device, reinterpret_cast<const VkImageViewHandleInfoNVX *>(&info)); | |
| return result; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getImageViewAddressNVX(VULKAN_HPP_NAMESPACE::ImageView imageView, | |
| VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX *pProperties, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>( | |
| d.vkGetImageViewAddressNVX(m_device, static_cast<VkImageView>(imageView), reinterpret_cast<VkImageViewAddressPropertiesNVX *>(pProperties))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX>::type | |
| Device::getImageViewAddressNVX(VULKAN_HPP_NAMESPACE::ImageView imageView, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX properties; | |
| VkResult result = | |
| d.vkGetImageViewAddressNVX(m_device, static_cast<VkImageView>(imageView), reinterpret_cast<VkImageViewAddressPropertiesNVX *>(&properties)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::getImageViewAddressNVX"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), properties); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_AMD_draw_indirect_count === | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountAMD(VULKAN_HPP_NAMESPACE::Buffer buffer, | |
| VULKAN_HPP_NAMESPACE::DeviceSize offset, | |
| VULKAN_HPP_NAMESPACE::Buffer countBuffer, | |
| VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, | |
| uint32_t maxDrawCount, | |
| uint32_t stride, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdDrawIndirectCountAMD(m_commandBuffer, | |
| static_cast<VkBuffer>(buffer), | |
| static_cast<VkDeviceSize>(offset), | |
| static_cast<VkBuffer>(countBuffer), | |
| static_cast<VkDeviceSize>(countBufferOffset), | |
| maxDrawCount, | |
| stride); | |
| } | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountAMD(VULKAN_HPP_NAMESPACE::Buffer buffer, | |
| VULKAN_HPP_NAMESPACE::DeviceSize offset, | |
| VULKAN_HPP_NAMESPACE::Buffer countBuffer, | |
| VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, | |
| uint32_t maxDrawCount, | |
| uint32_t stride, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdDrawIndexedIndirectCountAMD(m_commandBuffer, | |
| static_cast<VkBuffer>(buffer), | |
| static_cast<VkDeviceSize>(offset), | |
| static_cast<VkBuffer>(countBuffer), | |
| static_cast<VkDeviceSize>(countBufferOffset), | |
| maxDrawCount, | |
| stride); | |
| } | |
| //=== VK_AMD_shader_info === | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getShaderInfoAMD(VULKAN_HPP_NAMESPACE::Pipeline pipeline, | |
| VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage, | |
| VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD infoType, | |
| size_t *pInfoSize, | |
| void *pInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkGetShaderInfoAMD(m_device, | |
| static_cast<VkPipeline>(pipeline), | |
| static_cast<VkShaderStageFlagBits>(shaderStage), | |
| static_cast<VkShaderInfoTypeAMD>(infoType), | |
| pInfoSize, | |
| pInfo)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Uint8_tAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type | |
| Device::getShaderInfoAMD(VULKAN_HPP_NAMESPACE::Pipeline pipeline, | |
| VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage, | |
| VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD infoType, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| 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()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(infoSize <= info.size()); | |
| if(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()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(infoSize <= info.size()); | |
| if(infoSize < info.size()) | |
| { | |
| info.resize(infoSize); | |
| } | |
| } | |
| return createResultValue(result, info, VULKAN_HPP_NAMESPACE_STRING "::Device::getShaderInfoAMD"); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_KHR_dynamic_rendering === | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::beginRenderingKHR(const VULKAN_HPP_NAMESPACE::RenderingInfo *pRenderingInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdBeginRenderingKHR(m_commandBuffer, reinterpret_cast<const VkRenderingInfo *>(pRenderingInfo)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::beginRenderingKHR(const VULKAN_HPP_NAMESPACE::RenderingInfo &renderingInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdBeginRenderingKHR(m_commandBuffer, reinterpret_cast<const VkRenderingInfo *>(&renderingInfo)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::endRenderingKHR(Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdEndRenderingKHR(m_commandBuffer); | |
| } | |
| #if defined(VK_USE_PLATFORM_GGP) | |
| //=== VK_GGP_stream_descriptor_surface === | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Instance::createStreamDescriptorSurfaceGGP(const VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP *pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| VULKAN_HPP_NAMESPACE::SurfaceKHR *pSurface, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkCreateStreamDescriptorSurfaceGGP(m_instance, | |
| reinterpret_cast<const VkStreamDescriptorSurfaceCreateInfoGGP *>(pCreateInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(pAllocator), | |
| reinterpret_cast<VkSurfaceKHR *>(pSurface))); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type | |
| Instance::createStreamDescriptorSurfaceGGP(const VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface; | |
| VkResult 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)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Instance::createStreamDescriptorSurfaceGGP"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), surface); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type | |
| Instance::createStreamDescriptorSurfaceGGPUnique(const VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| 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 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; | |
| VkResult 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)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getExternalImageFormatPropertiesNV"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), externalImageFormatProperties); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #if defined(VK_USE_PLATFORM_WIN32_KHR) | |
| //=== VK_NV_external_memory_win32 === | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getMemoryWin32HandleNV(VULKAN_HPP_NAMESPACE::DeviceMemory memory, | |
| VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleType, | |
| HANDLE *pHandle, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>( | |
| d.vkGetMemoryWin32HandleNV(m_device, static_cast<VkDeviceMemory>(memory), static_cast<VkExternalMemoryHandleTypeFlagsNV>(handleType), pHandle)); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<HANDLE>::type Device::getMemoryWin32HandleNV( | |
| VULKAN_HPP_NAMESPACE::DeviceMemory memory, VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleType, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| HANDLE handle; | |
| VkResult result = | |
| d.vkGetMemoryWin32HandleNV(m_device, static_cast<VkDeviceMemory>(memory), static_cast<VkExternalMemoryHandleTypeFlagsNV>(handleType), &handle); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryWin32HandleNV"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), handle); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #endif /*VK_USE_PLATFORM_WIN32_KHR*/ | |
| //=== VK_KHR_get_physical_device_properties2 === | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void PhysicalDevice::getFeatures2KHR(VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 *pFeatures, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkGetPhysicalDeviceFeatures2KHR(m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2 *>(pFeatures)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 | |
| PhysicalDevice::getFeatures2KHR(Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| 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 VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>::type | |
| PhysicalDevice::getImageFormatProperties2KHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 &imageFormatInfo, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::ImageFormatProperties2 imageFormatProperties; | |
| VkResult result = d.vkGetPhysicalDeviceImageFormatProperties2KHR(m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>(&imageFormatInfo), | |
| reinterpret_cast<VkImageFormatProperties2 *>(&imageFormatProperties)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2KHR"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), imageFormatProperties); | |
| } | |
| template<typename X, typename Y, typename... Z, typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<StructureChain<X, Y, Z...>>::type | |
| PhysicalDevice::getImageFormatProperties2KHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 &imageFormatInfo, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| StructureChain<X, Y, Z...> structureChain; | |
| VULKAN_HPP_NAMESPACE::ImageFormatProperties2 &imageFormatProperties = structureChain.template get<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>(); | |
| Result result = | |
| static_cast<Result>(d.vkGetPhysicalDeviceImageFormatProperties2KHR(m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>(&imageFormatInfo), | |
| reinterpret_cast<VkImageFormatProperties2 *>(&imageFormatProperties))); | |
| return createResultValue(result, structureChain, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2KHR"); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void PhysicalDevice::getQueueFamilyProperties2KHR(uint32_t *pQueueFamilyPropertyCount, | |
| VULKAN_HPP_NAMESPACE::QueueFamilyProperties2 *pQueueFamilyProperties, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( | |
| m_physicalDevice, pQueueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2 *>(pQueueFamilyProperties)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename QueueFamilyProperties2Allocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator> | |
| PhysicalDevice::getQueueFamilyProperties2KHR(Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator> queueFamilyProperties; | |
| uint32_t queueFamilyPropertyCount; | |
| d.vkGetPhysicalDeviceQueueFamilyProperties2KHR(m_physicalDevice, &queueFamilyPropertyCount, nullptr); | |
| queueFamilyProperties.resize(queueFamilyPropertyCount); | |
| d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( | |
| m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2 *>(queueFamilyProperties.data())); | |
| VULKAN_HPP_ASSERT(queueFamilyPropertyCount <= queueFamilyProperties.size()); | |
| return queueFamilyProperties; | |
| } | |
| template<typename QueueFamilyProperties2Allocator, | |
| typename Dispatch, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, QueueFamilyProperties2>::value, int>::type> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator> | |
| PhysicalDevice::getQueueFamilyProperties2KHR(QueueFamilyProperties2Allocator &queueFamilyProperties2Allocator, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator> queueFamilyProperties(queueFamilyProperties2Allocator); | |
| uint32_t queueFamilyPropertyCount; | |
| d.vkGetPhysicalDeviceQueueFamilyProperties2KHR(m_physicalDevice, &queueFamilyPropertyCount, nullptr); | |
| queueFamilyProperties.resize(queueFamilyPropertyCount); | |
| d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( | |
| m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2 *>(queueFamilyProperties.data())); | |
| VULKAN_HPP_ASSERT(queueFamilyPropertyCount <= queueFamilyProperties.size()); | |
| return queueFamilyProperties; | |
| } | |
| template<typename StructureChain, typename StructureChainAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<StructureChain, StructureChainAllocator> | |
| PhysicalDevice::getQueueFamilyProperties2KHR(Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| uint32_t queueFamilyPropertyCount; | |
| d.vkGetPhysicalDeviceQueueFamilyProperties2KHR(m_physicalDevice, &queueFamilyPropertyCount, nullptr); | |
| std::vector<StructureChain, StructureChainAllocator> returnVector(queueFamilyPropertyCount); | |
| std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> queueFamilyProperties(queueFamilyPropertyCount); | |
| for(uint32_t i = 0; i < queueFamilyPropertyCount; i++) | |
| { | |
| queueFamilyProperties[i].pNext = returnVector[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>().pNext; | |
| } | |
| d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( | |
| m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2 *>(queueFamilyProperties.data())); | |
| VULKAN_HPP_ASSERT(queueFamilyPropertyCount <= queueFamilyProperties.size()); | |
| for(uint32_t i = 0; i < queueFamilyPropertyCount; i++) | |
| { | |
| returnVector[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>() = queueFamilyProperties[i]; | |
| } | |
| return returnVector; | |
| } | |
| template<typename StructureChain, | |
| typename StructureChainAllocator, | |
| typename Dispatch, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, StructureChain>::value, int>::type> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<StructureChain, StructureChainAllocator> | |
| PhysicalDevice::getQueueFamilyProperties2KHR(StructureChainAllocator &structureChainAllocator, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| uint32_t queueFamilyPropertyCount; | |
| d.vkGetPhysicalDeviceQueueFamilyProperties2KHR(m_physicalDevice, &queueFamilyPropertyCount, nullptr); | |
| std::vector<StructureChain, StructureChainAllocator> returnVector(queueFamilyPropertyCount, structureChainAllocator); | |
| std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> queueFamilyProperties(queueFamilyPropertyCount); | |
| for(uint32_t i = 0; i < queueFamilyPropertyCount; i++) | |
| { | |
| queueFamilyProperties[i].pNext = returnVector[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>().pNext; | |
| } | |
| d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( | |
| m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2 *>(queueFamilyProperties.data())); | |
| VULKAN_HPP_ASSERT(queueFamilyPropertyCount <= queueFamilyProperties.size()); | |
| for(uint32_t i = 0; i < queueFamilyPropertyCount; i++) | |
| { | |
| returnVector[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>() = queueFamilyProperties[i]; | |
| } | |
| return returnVector; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void PhysicalDevice::getMemoryProperties2KHR(VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 *pMemoryProperties, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkGetPhysicalDeviceMemoryProperties2KHR(m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>(pMemoryProperties)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 | |
| PhysicalDevice::getMemoryProperties2KHR(Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 memoryProperties; | |
| d.vkGetPhysicalDeviceMemoryProperties2KHR(m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>(&memoryProperties)); | |
| return memoryProperties; | |
| } | |
| template<typename X, typename Y, typename... Z, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getMemoryProperties2KHR(Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| StructureChain<X, Y, Z...> structureChain; | |
| VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 &memoryProperties = | |
| structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2>(); | |
| d.vkGetPhysicalDeviceMemoryProperties2KHR(m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>(&memoryProperties)); | |
| return structureChain; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void PhysicalDevice::getSparseImageFormatProperties2KHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, | |
| uint32_t *pPropertyCount, | |
| VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 *pProperties, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR(m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>(pFormatInfo), | |
| pPropertyCount, | |
| reinterpret_cast<VkSparseImageFormatProperties2 *>(pProperties)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename SparseImageFormatProperties2Allocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator> | |
| PhysicalDevice::getSparseImageFormatProperties2KHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 &formatInfo, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator> properties; | |
| uint32_t propertyCount; | |
| d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR( | |
| m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>(&formatInfo), &propertyCount, nullptr); | |
| properties.resize(propertyCount); | |
| d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR(m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>(&formatInfo), | |
| &propertyCount, | |
| reinterpret_cast<VkSparseImageFormatProperties2 *>(properties.data())); | |
| VULKAN_HPP_ASSERT(propertyCount <= properties.size()); | |
| return properties; | |
| } | |
| template<typename SparseImageFormatProperties2Allocator, | |
| typename Dispatch, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, SparseImageFormatProperties2>::value, int>::type> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator> | |
| PhysicalDevice::getSparseImageFormatProperties2KHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 &formatInfo, | |
| SparseImageFormatProperties2Allocator &sparseImageFormatProperties2Allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator> properties(sparseImageFormatProperties2Allocator); | |
| uint32_t propertyCount; | |
| d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR( | |
| m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>(&formatInfo), &propertyCount, nullptr); | |
| properties.resize(propertyCount); | |
| d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR(m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>(&formatInfo), | |
| &propertyCount, | |
| reinterpret_cast<VkSparseImageFormatProperties2 *>(properties.data())); | |
| VULKAN_HPP_ASSERT(propertyCount <= properties.size()); | |
| return properties; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_KHR_device_group === | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::getGroupPeerMemoryFeaturesKHR(uint32_t heapIndex, | |
| uint32_t localDeviceIndex, | |
| uint32_t remoteDeviceIndex, | |
| VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags *pPeerMemoryFeatures, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkGetDeviceGroupPeerMemoryFeaturesKHR( | |
| m_device, heapIndex, localDeviceIndex, remoteDeviceIndex, reinterpret_cast<VkPeerMemoryFeatureFlags *>(pPeerMemoryFeatures)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags Device::getGroupPeerMemoryFeaturesKHR( | |
| uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags peerMemoryFeatures; | |
| d.vkGetDeviceGroupPeerMemoryFeaturesKHR( | |
| m_device, heapIndex, localDeviceIndex, remoteDeviceIndex, reinterpret_cast<VkPeerMemoryFeatureFlags *>(&peerMemoryFeatures)); | |
| return peerMemoryFeatures; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setDeviceMaskKHR(uint32_t deviceMask, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdSetDeviceMaskKHR(m_commandBuffer, deviceMask); | |
| } | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::dispatchBaseKHR(uint32_t baseGroupX, | |
| uint32_t baseGroupY, | |
| uint32_t baseGroupZ, | |
| uint32_t groupCountX, | |
| uint32_t groupCountY, | |
| uint32_t groupCountZ, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdDispatchBaseKHR(m_commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ); | |
| } | |
| #if defined(VK_USE_PLATFORM_VI_NN) | |
| //=== VK_NN_vi_surface === | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createViSurfaceNN(const VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN *pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| VULKAN_HPP_NAMESPACE::SurfaceKHR *pSurface, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkCreateViSurfaceNN(m_instance, | |
| reinterpret_cast<const VkViSurfaceCreateInfoNN *>(pCreateInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(pAllocator), | |
| reinterpret_cast<VkSurfaceKHR *>(pSurface))); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type | |
| Instance::createViSurfaceNN(const VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface; | |
| VkResult 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)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Instance::createViSurfaceNN"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), surface); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type | |
| Instance::createViSurfaceNNUnique(const VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| 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()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(physicalDeviceGroupCount <= physicalDeviceGroupProperties.size()); | |
| if(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()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(physicalDeviceGroupCount <= physicalDeviceGroupProperties.size()); | |
| if(physicalDeviceGroupCount < physicalDeviceGroupProperties.size()) | |
| { | |
| physicalDeviceGroupProperties.resize(physicalDeviceGroupCount); | |
| } | |
| } | |
| return createResultValue(result, physicalDeviceGroupProperties, VULKAN_HPP_NAMESPACE_STRING "::Instance::enumeratePhysicalDeviceGroupsKHR"); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_KHR_external_memory_capabilities === | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void PhysicalDevice::getExternalBufferPropertiesKHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo *pExternalBufferInfo, | |
| VULKAN_HPP_NAMESPACE::ExternalBufferProperties *pExternalBufferProperties, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkGetPhysicalDeviceExternalBufferPropertiesKHR(m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo *>(pExternalBufferInfo), | |
| reinterpret_cast<VkExternalBufferProperties *>(pExternalBufferProperties)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalBufferProperties | |
| PhysicalDevice::getExternalBufferPropertiesKHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo &externalBufferInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::ExternalBufferProperties externalBufferProperties; | |
| d.vkGetPhysicalDeviceExternalBufferPropertiesKHR(m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo *>(&externalBufferInfo), | |
| reinterpret_cast<VkExternalBufferProperties *>(&externalBufferProperties)); | |
| return externalBufferProperties; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #if defined(VK_USE_PLATFORM_WIN32_KHR) | |
| //=== VK_KHR_external_memory_win32 === | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getMemoryWin32HandleKHR(const VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR *pGetWin32HandleInfo, | |
| HANDLE *pHandle, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>( | |
| d.vkGetMemoryWin32HandleKHR(m_device, reinterpret_cast<const VkMemoryGetWin32HandleInfoKHR *>(pGetWin32HandleInfo), pHandle)); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<HANDLE>::type | |
| Device::getMemoryWin32HandleKHR(const VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR &getWin32HandleInfo, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| HANDLE handle; | |
| VkResult result = d.vkGetMemoryWin32HandleKHR(m_device, reinterpret_cast<const VkMemoryGetWin32HandleInfoKHR *>(&getWin32HandleInfo), &handle); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryWin32HandleKHR"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), handle); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::getMemoryWin32HandlePropertiesKHR(VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, | |
| HANDLE handle, | |
| VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR *pMemoryWin32HandleProperties, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkGetMemoryWin32HandlePropertiesKHR(m_device, | |
| static_cast<VkExternalMemoryHandleTypeFlagBits>(handleType), | |
| handle, | |
| reinterpret_cast<VkMemoryWin32HandlePropertiesKHR *>(pMemoryWin32HandleProperties))); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR>::type | |
| Device::getMemoryWin32HandlePropertiesKHR(VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR memoryWin32HandleProperties; | |
| VkResult result = d.vkGetMemoryWin32HandlePropertiesKHR(m_device, | |
| static_cast<VkExternalMemoryHandleTypeFlagBits>(handleType), | |
| handle, | |
| reinterpret_cast<VkMemoryWin32HandlePropertiesKHR *>(&memoryWin32HandleProperties)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryWin32HandlePropertiesKHR"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), memoryWin32HandleProperties); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #endif /*VK_USE_PLATFORM_WIN32_KHR*/ | |
| //=== VK_KHR_external_memory_fd === | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getMemoryFdKHR(const VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR *pGetFdInfo, | |
| int *pFd, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkGetMemoryFdKHR(m_device, reinterpret_cast<const VkMemoryGetFdInfoKHR *>(pGetFdInfo), pFd)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<int>::type Device::getMemoryFdKHR(const VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR &getFdInfo, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| int fd; | |
| VkResult result = d.vkGetMemoryFdKHR(m_device, reinterpret_cast<const VkMemoryGetFdInfoKHR *>(&getFdInfo), &fd); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryFdKHR"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), fd); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getMemoryFdPropertiesKHR(VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, | |
| int fd, | |
| VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR *pMemoryFdProperties, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkGetMemoryFdPropertiesKHR( | |
| m_device, static_cast<VkExternalMemoryHandleTypeFlagBits>(handleType), fd, reinterpret_cast<VkMemoryFdPropertiesKHR *>(pMemoryFdProperties))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR>::type | |
| Device::getMemoryFdPropertiesKHR(VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, int fd, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR memoryFdProperties; | |
| VkResult result = d.vkGetMemoryFdPropertiesKHR( | |
| m_device, static_cast<VkExternalMemoryHandleTypeFlagBits>(handleType), fd, reinterpret_cast<VkMemoryFdPropertiesKHR *>(&memoryFdProperties)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryFdPropertiesKHR"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), memoryFdProperties); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_KHR_external_semaphore_capabilities === | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| PhysicalDevice::getExternalSemaphorePropertiesKHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo, | |
| VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties *pExternalSemaphoreProperties, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo *>(pExternalSemaphoreInfo), | |
| reinterpret_cast<VkExternalSemaphoreProperties *>(pExternalSemaphoreProperties)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties | |
| PhysicalDevice::getExternalSemaphorePropertiesKHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo &externalSemaphoreInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties externalSemaphoreProperties; | |
| d.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo *>(&externalSemaphoreInfo), | |
| reinterpret_cast<VkExternalSemaphoreProperties *>(&externalSemaphoreProperties)); | |
| return externalSemaphoreProperties; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #if defined(VK_USE_PLATFORM_WIN32_KHR) | |
| //=== VK_KHR_external_semaphore_win32 === | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::importSemaphoreWin32HandleKHR( | |
| const VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR *pImportSemaphoreWin32HandleInfo, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>( | |
| d.vkImportSemaphoreWin32HandleKHR(m_device, reinterpret_cast<const VkImportSemaphoreWin32HandleInfoKHR *>(pImportSemaphoreWin32HandleInfo))); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| Device::importSemaphoreWin32HandleKHR(const VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR &importSemaphoreWin32HandleInfo, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VkResult result = | |
| d.vkImportSemaphoreWin32HandleKHR(m_device, reinterpret_cast<const VkImportSemaphoreWin32HandleInfoKHR *>(&importSemaphoreWin32HandleInfo)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::importSemaphoreWin32HandleKHR"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result)); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSemaphoreWin32HandleKHR( | |
| const VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR *pGetWin32HandleInfo, HANDLE *pHandle, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>( | |
| d.vkGetSemaphoreWin32HandleKHR(m_device, reinterpret_cast<const VkSemaphoreGetWin32HandleInfoKHR *>(pGetWin32HandleInfo), pHandle)); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<HANDLE>::type | |
| Device::getSemaphoreWin32HandleKHR(const VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR &getWin32HandleInfo, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| HANDLE handle; | |
| VkResult result = d.vkGetSemaphoreWin32HandleKHR(m_device, reinterpret_cast<const VkSemaphoreGetWin32HandleInfoKHR *>(&getWin32HandleInfo), &handle); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreWin32HandleKHR"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), handle); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #endif /*VK_USE_PLATFORM_WIN32_KHR*/ | |
| //=== VK_KHR_external_semaphore_fd === | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::importSemaphoreFdKHR(const VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR *pImportSemaphoreFdInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkImportSemaphoreFdKHR(m_device, reinterpret_cast<const VkImportSemaphoreFdInfoKHR *>(pImportSemaphoreFdInfo))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| Device::importSemaphoreFdKHR(const VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR &importSemaphoreFdInfo, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VkResult result = d.vkImportSemaphoreFdKHR(m_device, reinterpret_cast<const VkImportSemaphoreFdInfoKHR *>(&importSemaphoreFdInfo)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::importSemaphoreFdKHR"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSemaphoreFdKHR(const VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR *pGetFdInfo, | |
| int *pFd, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkGetSemaphoreFdKHR(m_device, reinterpret_cast<const VkSemaphoreGetFdInfoKHR *>(pGetFdInfo), pFd)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<int>::type | |
| Device::getSemaphoreFdKHR(const VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR &getFdInfo, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| int fd; | |
| VkResult result = d.vkGetSemaphoreFdKHR(m_device, reinterpret_cast<const VkSemaphoreGetFdInfoKHR *>(&getFdInfo), &fd); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreFdKHR"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), fd); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_KHR_push_descriptor === | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetKHR(VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, | |
| VULKAN_HPP_NAMESPACE::PipelineLayout layout, | |
| uint32_t set, | |
| uint32_t descriptorWriteCount, | |
| const VULKAN_HPP_NAMESPACE::WriteDescriptorSet *pDescriptorWrites, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdPushDescriptorSetKHR(m_commandBuffer, | |
| static_cast<VkPipelineBindPoint>(pipelineBindPoint), | |
| static_cast<VkPipelineLayout>(layout), | |
| set, | |
| descriptorWriteCount, | |
| reinterpret_cast<const VkWriteDescriptorSet *>(pDescriptorWrites)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetKHR(VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, | |
| VULKAN_HPP_NAMESPACE::PipelineLayout layout, | |
| uint32_t set, | |
| 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); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename DataType, typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplateKHR(VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, | |
| VULKAN_HPP_NAMESPACE::PipelineLayout layout, | |
| uint32_t set, | |
| DataType const &data, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdPushDescriptorSetWithTemplateKHR(m_commandBuffer, | |
| static_cast<VkDescriptorUpdateTemplate>(descriptorUpdateTemplate), | |
| static_cast<VkPipelineLayout>(layout), | |
| set, | |
| reinterpret_cast<const void *>(&data)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_EXT_conditional_rendering === | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::beginConditionalRenderingEXT(const VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT *pConditionalRenderingBegin, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdBeginConditionalRenderingEXT(m_commandBuffer, reinterpret_cast<const VkConditionalRenderingBeginInfoEXT *>(pConditionalRenderingBegin)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::beginConditionalRenderingEXT(const VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT &conditionalRenderingBegin, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdBeginConditionalRenderingEXT(m_commandBuffer, reinterpret_cast<const VkConditionalRenderingBeginInfoEXT *>(&conditionalRenderingBegin)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::endConditionalRenderingEXT(Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdEndConditionalRenderingEXT(m_commandBuffer); | |
| } | |
| //=== VK_KHR_descriptor_update_template === | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::createDescriptorUpdateTemplateKHR(const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo *pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate *pDescriptorUpdateTemplate, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkCreateDescriptorUpdateTemplateKHR(m_device, | |
| reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo *>(pCreateInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(pAllocator), | |
| reinterpret_cast<VkDescriptorUpdateTemplate *>(pDescriptorUpdateTemplate))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate>::type | |
| Device::createDescriptorUpdateTemplateKHR(const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate; | |
| VkResult 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)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorUpdateTemplateKHR"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), descriptorUpdateTemplate); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate, Dispatch>>::type | |
| Device::createDescriptorUpdateTemplateKHRUnique(const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| 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 VULKAN_HPP_NAMESPACE::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); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename DataType, typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::updateDescriptorSetWithTemplateKHR(VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet, | |
| VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, | |
| DataType const &data, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkUpdateDescriptorSetWithTemplateKHR(m_device, | |
| static_cast<VkDescriptorSet>(descriptorSet), | |
| static_cast<VkDescriptorUpdateTemplate>(descriptorUpdateTemplate), | |
| reinterpret_cast<const void *>(&data)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_NV_clip_space_w_scaling === | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setViewportWScalingNV(uint32_t firstViewport, | |
| uint32_t viewportCount, | |
| const VULKAN_HPP_NAMESPACE::ViewportWScalingNV *pViewportWScalings, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdSetViewportWScalingNV(m_commandBuffer, firstViewport, viewportCount, reinterpret_cast<const VkViewportWScalingNV *>(pViewportWScalings)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setViewportWScalingNV(uint32_t firstViewport, | |
| 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 void PhysicalDevice::releaseDisplayEXT(VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkReleaseDisplayEXT(m_physicalDevice, static_cast<VkDisplayKHR>(display)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #if defined(VK_USE_PLATFORM_XLIB_XRANDR_EXT) | |
| //=== VK_EXT_acquire_xlib_display === | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::acquireXlibDisplayEXT(Display *dpy, | |
| VULKAN_HPP_NAMESPACE::DisplayKHR display, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkAcquireXlibDisplayEXT(m_physicalDevice, dpy, static_cast<VkDisplayKHR>(display))); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| PhysicalDevice::acquireXlibDisplayEXT(Display &dpy, VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VkResult result = d.vkAcquireXlibDisplayEXT(m_physicalDevice, &dpy, static_cast<VkDisplayKHR>(display)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::acquireXlibDisplayEXT"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result)); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getRandROutputDisplayEXT(Display *dpy, | |
| RROutput rrOutput, | |
| VULKAN_HPP_NAMESPACE::DisplayKHR *pDisplay, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkGetRandROutputDisplayEXT(m_physicalDevice, dpy, rrOutput, reinterpret_cast<VkDisplayKHR *>(pDisplay))); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayKHR>::type | |
| PhysicalDevice::getRandROutputDisplayEXT(Display &dpy, RROutput rrOutput, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::DisplayKHR display; | |
| VkResult result = d.vkGetRandROutputDisplayEXT(m_physicalDevice, &dpy, rrOutput, reinterpret_cast<VkDisplayKHR *>(&display)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getRandROutputDisplayEXT"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), display); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>>::type | |
| PhysicalDevice::getRandROutputDisplayEXTUnique(Display &dpy, RROutput rrOutput, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| 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 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; | |
| VkResult result = d.vkGetPhysicalDeviceSurfaceCapabilities2EXT( | |
| m_physicalDevice, static_cast<VkSurfaceKHR>(surface), reinterpret_cast<VkSurfaceCapabilities2EXT *>(&surfaceCapabilities)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilities2EXT"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), surfaceCapabilities); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_EXT_display_control === | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::displayPowerControlEXT(VULKAN_HPP_NAMESPACE::DisplayKHR display, | |
| const VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT *pDisplayPowerInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>( | |
| d.vkDisplayPowerControlEXT(m_device, static_cast<VkDisplayKHR>(display), reinterpret_cast<const VkDisplayPowerInfoEXT *>(pDisplayPowerInfo))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::displayPowerControlEXT(VULKAN_HPP_NAMESPACE::DisplayKHR display, | |
| const VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT &displayPowerInfo, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VkResult result = | |
| d.vkDisplayPowerControlEXT(m_device, static_cast<VkDisplayKHR>(display), reinterpret_cast<const VkDisplayPowerInfoEXT *>(&displayPowerInfo)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::displayPowerControlEXT"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::registerEventEXT(const VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT *pDeviceEventInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| VULKAN_HPP_NAMESPACE::Fence *pFence, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkRegisterDeviceEventEXT(m_device, | |
| reinterpret_cast<const VkDeviceEventInfoEXT *>(pDeviceEventInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(pAllocator), | |
| reinterpret_cast<VkFence *>(pFence))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::Fence>::type | |
| Device::registerEventEXT(const VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT &deviceEventInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::Fence fence; | |
| VkResult 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)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::registerEventEXT"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), fence); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>>::type | |
| Device::registerEventEXTUnique(const VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT &deviceEventInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| 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_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::Fence>::type | |
| Device::registerDisplayEventEXT(VULKAN_HPP_NAMESPACE::DisplayKHR display, | |
| const VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT &displayEventInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::Fence fence; | |
| VkResult 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)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::registerDisplayEventEXT"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), fence); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>>::type | |
| Device::registerDisplayEventEXTUnique(VULKAN_HPP_NAMESPACE::DisplayKHR display, | |
| const VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT &displayEventInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| 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 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; | |
| VkResult result = | |
| d.vkGetSwapchainCounterEXT(m_device, static_cast<VkSwapchainKHR>(swapchain), static_cast<VkSurfaceCounterFlagBitsEXT>(counter), &counterValue); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::getSwapchainCounterEXT"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), counterValue); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_GOOGLE_display_timing === | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::getRefreshCycleDurationGOOGLE(VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, | |
| VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE *pDisplayTimingProperties, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkGetRefreshCycleDurationGOOGLE( | |
| m_device, static_cast<VkSwapchainKHR>(swapchain), reinterpret_cast<VkRefreshCycleDurationGOOGLE *>(pDisplayTimingProperties))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE>::type | |
| Device::getRefreshCycleDurationGOOGLE(VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE displayTimingProperties; | |
| VkResult result = d.vkGetRefreshCycleDurationGOOGLE( | |
| m_device, static_cast<VkSwapchainKHR>(swapchain), reinterpret_cast<VkRefreshCycleDurationGOOGLE *>(&displayTimingProperties)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::getRefreshCycleDurationGOOGLE"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), displayTimingProperties); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::getPastPresentationTimingGOOGLE(VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, | |
| uint32_t *pPresentationTimingCount, | |
| VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE *pPresentationTimings, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkGetPastPresentationTimingGOOGLE(m_device, | |
| static_cast<VkSwapchainKHR>(swapchain), | |
| pPresentationTimingCount, | |
| reinterpret_cast<VkPastPresentationTimingGOOGLE *>(pPresentationTimings))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename PastPresentationTimingGOOGLEAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<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()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(presentationTimingCount <= presentationTimings.size()); | |
| if(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()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(presentationTimingCount <= presentationTimings.size()); | |
| if(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 VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::RenderPass>::type | |
| Device::createRenderPass2KHR(const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::RenderPass renderPass; | |
| VkResult 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)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPass2KHR"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), renderPass); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>>::type | |
| Device::createRenderPass2KHRUnique(const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| 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 VULKAN_HPP_NAMESPACE::RenderPassBeginInfo &renderPassBegin, | |
| const VULKAN_HPP_NAMESPACE::SubpassBeginInfo &subpassBeginInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdBeginRenderPass2KHR( | |
| m_commandBuffer, reinterpret_cast<const VkRenderPassBeginInfo *>(&renderPassBegin), reinterpret_cast<const VkSubpassBeginInfo *>(&subpassBeginInfo)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::nextSubpass2KHR(const VULKAN_HPP_NAMESPACE::SubpassBeginInfo *pSubpassBeginInfo, | |
| const VULKAN_HPP_NAMESPACE::SubpassEndInfo *pSubpassEndInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdNextSubpass2KHR( | |
| m_commandBuffer, reinterpret_cast<const VkSubpassBeginInfo *>(pSubpassBeginInfo), reinterpret_cast<const VkSubpassEndInfo *>(pSubpassEndInfo)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::nextSubpass2KHR(const VULKAN_HPP_NAMESPACE::SubpassBeginInfo &subpassBeginInfo, | |
| const VULKAN_HPP_NAMESPACE::SubpassEndInfo &subpassEndInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdNextSubpass2KHR( | |
| m_commandBuffer, reinterpret_cast<const VkSubpassBeginInfo *>(&subpassBeginInfo), reinterpret_cast<const VkSubpassEndInfo *>(&subpassEndInfo)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::endRenderPass2KHR(const VULKAN_HPP_NAMESPACE::SubpassEndInfo *pSubpassEndInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdEndRenderPass2KHR(m_commandBuffer, reinterpret_cast<const VkSubpassEndInfo *>(pSubpassEndInfo)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::endRenderPass2KHR(const VULKAN_HPP_NAMESPACE::SubpassEndInfo &subpassEndInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdEndRenderPass2KHR(m_commandBuffer, reinterpret_cast<const VkSubpassEndInfo *>(&subpassEndInfo)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_KHR_shared_presentable_image === | |
| #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSwapchainStatusKHR(VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkGetSwapchainStatusKHR(m_device, static_cast<VkSwapchainKHR>(swapchain))); | |
| } | |
| #else | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result Device::getSwapchainStatusKHR(VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VkResult result = d.vkGetSwapchainStatusKHR(m_device, static_cast<VkSwapchainKHR>(swapchain)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::getSwapchainStatusKHR", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR }); | |
| return static_cast<VULKAN_HPP_NAMESPACE::Result>(result); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_KHR_external_fence_capabilities === | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void PhysicalDevice::getExternalFencePropertiesKHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo *pExternalFenceInfo, | |
| VULKAN_HPP_NAMESPACE::ExternalFenceProperties *pExternalFenceProperties, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkGetPhysicalDeviceExternalFencePropertiesKHR(m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo *>(pExternalFenceInfo), | |
| reinterpret_cast<VkExternalFenceProperties *>(pExternalFenceProperties)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalFenceProperties | |
| PhysicalDevice::getExternalFencePropertiesKHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo &externalFenceInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::ExternalFenceProperties externalFenceProperties; | |
| d.vkGetPhysicalDeviceExternalFencePropertiesKHR(m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo *>(&externalFenceInfo), | |
| reinterpret_cast<VkExternalFenceProperties *>(&externalFenceProperties)); | |
| return externalFenceProperties; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #if defined(VK_USE_PLATFORM_WIN32_KHR) | |
| //=== VK_KHR_external_fence_win32 === | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::importFenceWin32HandleKHR( | |
| const VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR *pImportFenceWin32HandleInfo, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>( | |
| d.vkImportFenceWin32HandleKHR(m_device, reinterpret_cast<const VkImportFenceWin32HandleInfoKHR *>(pImportFenceWin32HandleInfo))); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| Device::importFenceWin32HandleKHR(const VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR &importFenceWin32HandleInfo, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VkResult result = d.vkImportFenceWin32HandleKHR(m_device, reinterpret_cast<const VkImportFenceWin32HandleInfoKHR *>(&importFenceWin32HandleInfo)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::importFenceWin32HandleKHR"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result)); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getFenceWin32HandleKHR(const VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR *pGetWin32HandleInfo, | |
| HANDLE *pHandle, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>( | |
| d.vkGetFenceWin32HandleKHR(m_device, reinterpret_cast<const VkFenceGetWin32HandleInfoKHR *>(pGetWin32HandleInfo), pHandle)); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<HANDLE>::type | |
| Device::getFenceWin32HandleKHR(const VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR &getWin32HandleInfo, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| HANDLE handle; | |
| VkResult result = d.vkGetFenceWin32HandleKHR(m_device, reinterpret_cast<const VkFenceGetWin32HandleInfoKHR *>(&getWin32HandleInfo), &handle); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::getFenceWin32HandleKHR"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), handle); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #endif /*VK_USE_PLATFORM_WIN32_KHR*/ | |
| //=== VK_KHR_external_fence_fd === | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::importFenceFdKHR(const VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR *pImportFenceFdInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkImportFenceFdKHR(m_device, reinterpret_cast<const VkImportFenceFdInfoKHR *>(pImportFenceFdInfo))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| Device::importFenceFdKHR(const VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR &importFenceFdInfo, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VkResult result = d.vkImportFenceFdKHR(m_device, reinterpret_cast<const VkImportFenceFdInfoKHR *>(&importFenceFdInfo)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::importFenceFdKHR"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getFenceFdKHR(const VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR *pGetFdInfo, | |
| int *pFd, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkGetFenceFdKHR(m_device, reinterpret_cast<const VkFenceGetFdInfoKHR *>(pGetFdInfo), pFd)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<int>::type Device::getFenceFdKHR(const VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR &getFdInfo, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| int fd; | |
| VkResult result = d.vkGetFenceFdKHR(m_device, reinterpret_cast<const VkFenceGetFdInfoKHR *>(&getFdInfo), &fd); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::getFenceFdKHR"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), fd); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_KHR_performance_query === | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR(uint32_t queueFamilyIndex, | |
| uint32_t *pCounterCount, | |
| VULKAN_HPP_NAMESPACE::PerformanceCounterKHR *pCounters, | |
| VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR *pCounterDescriptions, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>( | |
| d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(m_physicalDevice, | |
| queueFamilyIndex, | |
| pCounterCount, | |
| reinterpret_cast<VkPerformanceCounterKHR *>(pCounters), | |
| reinterpret_cast<VkPerformanceCounterDescriptionKHR *>(pCounterDescriptions))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename PerformanceCounterKHRAllocator, typename PerformanceCounterDescriptionKHRAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE | |
| typename ResultValueType<std::pair<std::vector<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 VULKAN_HPP_NAMESPACE::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 VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR &info, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VkResult result = d.vkAcquireProfilingLockKHR(m_device, reinterpret_cast<const VkAcquireProfilingLockInfoKHR *>(&info)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::acquireProfilingLockKHR"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::releaseProfilingLockKHR(Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkReleaseProfilingLockKHR(m_device); | |
| } | |
| //=== VK_KHR_get_surface_capabilities2 === | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| PhysicalDevice::getSurfaceCapabilities2KHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, | |
| VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR *pSurfaceCapabilities, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkGetPhysicalDeviceSurfaceCapabilities2KHR(m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>(pSurfaceInfo), | |
| reinterpret_cast<VkSurfaceCapabilities2KHR *>(pSurfaceCapabilities))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR>::type | |
| PhysicalDevice::getSurfaceCapabilities2KHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR &surfaceInfo, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR surfaceCapabilities; | |
| VkResult result = d.vkGetPhysicalDeviceSurfaceCapabilities2KHR(m_physicalDevice, | |
| reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>(&surfaceInfo), | |
| reinterpret_cast<VkSurfaceCapabilities2KHR *>(&surfaceCapabilities)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilities2KHR"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), surfaceCapabilities); | |
| } | |
| 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 VULKAN_HPP_NAMESPACE::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 VULKAN_HPP_NAMESPACE::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()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(surfaceFormatCount <= surfaceFormats.size()); | |
| if(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 VULKAN_HPP_NAMESPACE::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()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(surfaceFormatCount <= surfaceFormats.size()); | |
| if(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()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(propertyCount <= properties.size()); | |
| if(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()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(propertyCount <= properties.size()); | |
| if(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()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(propertyCount <= properties.size()); | |
| if(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()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(propertyCount <= properties.size()); | |
| if(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()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(propertyCount <= properties.size()); | |
| if(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()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(propertyCount <= properties.size()); | |
| if(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 VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR>::type | |
| PhysicalDevice::getDisplayPlaneCapabilities2KHR(const VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR &displayPlaneInfo, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR capabilities; | |
| VkResult result = d.vkGetDisplayPlaneCapabilities2KHR(m_physicalDevice, | |
| reinterpret_cast<const VkDisplayPlaneInfo2KHR *>(&displayPlaneInfo), | |
| reinterpret_cast<VkDisplayPlaneCapabilities2KHR *>(&capabilities)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneCapabilities2KHR"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), capabilities); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #if defined(VK_USE_PLATFORM_IOS_MVK) | |
| //=== VK_MVK_ios_surface === | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createIOSSurfaceMVK(const VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK *pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| VULKAN_HPP_NAMESPACE::SurfaceKHR *pSurface, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkCreateIOSSurfaceMVK(m_instance, | |
| reinterpret_cast<const VkIOSSurfaceCreateInfoMVK *>(pCreateInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(pAllocator), | |
| reinterpret_cast<VkSurfaceKHR *>(pSurface))); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type | |
| Instance::createIOSSurfaceMVK(const VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface; | |
| VkResult 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)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Instance::createIOSSurfaceMVK"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), surface); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type | |
| Instance::createIOSSurfaceMVKUnique(const VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| 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 VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type | |
| Instance::createMacOSSurfaceMVK(const VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface; | |
| VkResult 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)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Instance::createMacOSSurfaceMVK"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), surface); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type | |
| Instance::createMacOSSurfaceMVKUnique(const VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| 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 VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT &nameInfo, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VkResult result = d.vkSetDebugUtilsObjectNameEXT(m_device, reinterpret_cast<const VkDebugUtilsObjectNameInfoEXT *>(&nameInfo)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::setDebugUtilsObjectNameEXT"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::setDebugUtilsObjectTagEXT(const VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT *pTagInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkSetDebugUtilsObjectTagEXT(m_device, reinterpret_cast<const VkDebugUtilsObjectTagInfoEXT *>(pTagInfo))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| Device::setDebugUtilsObjectTagEXT(const VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT &tagInfo, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VkResult result = d.vkSetDebugUtilsObjectTagEXT(m_device, reinterpret_cast<const VkDebugUtilsObjectTagInfoEXT *>(&tagInfo)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::setDebugUtilsObjectTagEXT"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Queue::beginDebugUtilsLabelEXT(const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT *pLabelInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkQueueBeginDebugUtilsLabelEXT(m_queue, reinterpret_cast<const VkDebugUtilsLabelEXT *>(pLabelInfo)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Queue::beginDebugUtilsLabelEXT(const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT &labelInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkQueueBeginDebugUtilsLabelEXT(m_queue, reinterpret_cast<const VkDebugUtilsLabelEXT *>(&labelInfo)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Queue::endDebugUtilsLabelEXT(Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkQueueEndDebugUtilsLabelEXT(m_queue); | |
| } | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Queue::insertDebugUtilsLabelEXT(const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT *pLabelInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkQueueInsertDebugUtilsLabelEXT(m_queue, reinterpret_cast<const VkDebugUtilsLabelEXT *>(pLabelInfo)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Queue::insertDebugUtilsLabelEXT(const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT &labelInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkQueueInsertDebugUtilsLabelEXT(m_queue, reinterpret_cast<const VkDebugUtilsLabelEXT *>(&labelInfo)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::beginDebugUtilsLabelEXT(const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT *pLabelInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdBeginDebugUtilsLabelEXT(m_commandBuffer, reinterpret_cast<const VkDebugUtilsLabelEXT *>(pLabelInfo)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::beginDebugUtilsLabelEXT(const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT &labelInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdBeginDebugUtilsLabelEXT(m_commandBuffer, reinterpret_cast<const VkDebugUtilsLabelEXT *>(&labelInfo)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::endDebugUtilsLabelEXT(Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdEndDebugUtilsLabelEXT(m_commandBuffer); | |
| } | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::insertDebugUtilsLabelEXT(const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT *pLabelInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdInsertDebugUtilsLabelEXT(m_commandBuffer, reinterpret_cast<const VkDebugUtilsLabelEXT *>(pLabelInfo)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::insertDebugUtilsLabelEXT(const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT &labelInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdInsertDebugUtilsLabelEXT(m_commandBuffer, reinterpret_cast<const VkDebugUtilsLabelEXT *>(&labelInfo)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Instance::createDebugUtilsMessengerEXT(const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT *pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT *pMessenger, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkCreateDebugUtilsMessengerEXT(m_instance, | |
| reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT *>(pCreateInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(pAllocator), | |
| reinterpret_cast<VkDebugUtilsMessengerEXT *>(pMessenger))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT>::type | |
| Instance::createDebugUtilsMessengerEXT(const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger; | |
| VkResult 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)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Instance::createDebugUtilsMessengerEXT"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), messenger); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT, Dispatch>>::type | |
| Instance::createDebugUtilsMessengerEXTUnique(const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| 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 VULKAN_HPP_NAMESPACE::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 VULKAN_HPP_NAMESPACE::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 VULKAN_HPP_NAMESPACE::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 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; | |
| VkResult result = | |
| d.vkGetAndroidHardwareBufferPropertiesANDROID(m_device, &buffer, reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID *>(&properties)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::getAndroidHardwareBufferPropertiesANDROID"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), properties); | |
| } | |
| 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 VULKAN_HPP_INLINE typename ResultValueType<struct AHardwareBuffer *>::type | |
| Device::getMemoryAndroidHardwareBufferANDROID(const VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID &info, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| struct AHardwareBuffer *buffer; | |
| VkResult result = | |
| d.vkGetMemoryAndroidHardwareBufferANDROID(m_device, reinterpret_cast<const VkMemoryGetAndroidHardwareBufferInfoANDROID *>(&info), &buffer); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryAndroidHardwareBufferANDROID"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), buffer); | |
| } | |
| # 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 VULKAN_HPP_NAMESPACE::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 VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 &info, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements; | |
| d.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 VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 &info, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| StructureChain<X, Y, Z...> structureChain; | |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 &memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>(); | |
| d.vkGetImageMemoryRequirements2KHR( | |
| m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>(&info), reinterpret_cast<VkMemoryRequirements2 *>(&memoryRequirements)); | |
| return structureChain; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::getBufferMemoryRequirements2KHR(const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 *pInfo, | |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 *pMemoryRequirements, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkGetBufferMemoryRequirements2KHR( | |
| m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>(pInfo), reinterpret_cast<VkMemoryRequirements2 *>(pMemoryRequirements)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2 | |
| Device::getBufferMemoryRequirements2KHR(const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 &info, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| 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 VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 &info, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| StructureChain<X, Y, Z...> structureChain; | |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 &memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>(); | |
| d.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 VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 &info, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> sparseMemoryRequirements; | |
| uint32_t sparseMemoryRequirementCount; | |
| d.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 VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 &info, | |
| SparseImageMemoryRequirements2Allocator &sparseImageMemoryRequirements2Allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> sparseMemoryRequirements(sparseImageMemoryRequirements2Allocator); | |
| uint32_t sparseMemoryRequirementCount; | |
| d.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 VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR>::type | |
| Device::createAccelerationStructureKHR(const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure; | |
| VkResult 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)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::createAccelerationStructureKHR"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), accelerationStructure); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR, Dispatch>>::type | |
| Device::createAccelerationStructureKHRUnique(const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| 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 VULKAN_HPP_NAMESPACE::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 VULKAN_HPP_NAMESPACE::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_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::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_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*/ | |
| VkResult result = | |
| d.vkBuildAccelerationStructuresKHR(m_device, | |
| static_cast<VkDeferredOperationKHR>(deferredOperation), | |
| infos.size(), | |
| reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>(infos.data()), | |
| reinterpret_cast<const VkAccelerationStructureBuildRangeInfoKHR *const *>(pBuildRangeInfos.data())); | |
| resultCheck( | |
| static_cast<VULKAN_HPP_NAMESPACE::Result>(result), | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::buildAccelerationStructuresKHR", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR, VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR }); | |
| return static_cast<VULKAN_HPP_NAMESPACE::Result>(result); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyAccelerationStructureKHR(VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, | |
| const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR *pInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkCopyAccelerationStructureKHR( | |
| m_device, static_cast<VkDeferredOperationKHR>(deferredOperation), reinterpret_cast<const VkCopyAccelerationStructureInfoKHR *>(pInfo))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result | |
| Device::copyAccelerationStructureKHR(VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, | |
| const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR &info, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VkResult result = d.vkCopyAccelerationStructureKHR( | |
| m_device, static_cast<VkDeferredOperationKHR>(deferredOperation), reinterpret_cast<const VkCopyAccelerationStructureInfoKHR *>(&info)); | |
| resultCheck( | |
| static_cast<VULKAN_HPP_NAMESPACE::Result>(result), | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::copyAccelerationStructureKHR", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR, VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR }); | |
| return static_cast<VULKAN_HPP_NAMESPACE::Result>(result); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::copyAccelerationStructureToMemoryKHR(VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, | |
| const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR *pInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkCopyAccelerationStructureToMemoryKHR( | |
| m_device, static_cast<VkDeferredOperationKHR>(deferredOperation), reinterpret_cast<const VkCopyAccelerationStructureToMemoryInfoKHR *>(pInfo))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result | |
| Device::copyAccelerationStructureToMemoryKHR(VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, | |
| const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR &info, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VkResult result = d.vkCopyAccelerationStructureToMemoryKHR( | |
| m_device, static_cast<VkDeferredOperationKHR>(deferredOperation), reinterpret_cast<const VkCopyAccelerationStructureToMemoryInfoKHR *>(&info)); | |
| resultCheck( | |
| static_cast<VULKAN_HPP_NAMESPACE::Result>(result), | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::copyAccelerationStructureToMemoryKHR", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR, VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR }); | |
| return static_cast<VULKAN_HPP_NAMESPACE::Result>(result); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::copyMemoryToAccelerationStructureKHR(VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, | |
| const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR *pInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkCopyMemoryToAccelerationStructureKHR( | |
| m_device, static_cast<VkDeferredOperationKHR>(deferredOperation), reinterpret_cast<const VkCopyMemoryToAccelerationStructureInfoKHR *>(pInfo))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result | |
| Device::copyMemoryToAccelerationStructureKHR(VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, | |
| const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR &info, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VkResult result = d.vkCopyMemoryToAccelerationStructureKHR( | |
| m_device, static_cast<VkDeferredOperationKHR>(deferredOperation), reinterpret_cast<const VkCopyMemoryToAccelerationStructureInfoKHR *>(&info)); | |
| resultCheck( | |
| static_cast<VULKAN_HPP_NAMESPACE::Result>(result), | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::copyMemoryToAccelerationStructureKHR", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR, VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR }); | |
| return static_cast<VULKAN_HPP_NAMESPACE::Result>(result); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::writeAccelerationStructuresPropertiesKHR(uint32_t accelerationStructureCount, | |
| const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR *pAccelerationStructures, | |
| VULKAN_HPP_NAMESPACE::QueryType queryType, | |
| size_t dataSize, | |
| void *pData, | |
| size_t stride, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkWriteAccelerationStructuresPropertiesKHR(m_device, | |
| accelerationStructureCount, | |
| reinterpret_cast<const VkAccelerationStructureKHR *>(pAccelerationStructures), | |
| static_cast<VkQueryType>(queryType), | |
| dataSize, | |
| pData, | |
| stride)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename DataType, typename DataTypeAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type | |
| Device::writeAccelerationStructuresPropertiesKHR(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(DataType) == 0); | |
| std::vector<DataType, DataTypeAllocator> data(dataSize / sizeof(DataType)); | |
| Result result = | |
| static_cast<Result>(d.vkWriteAccelerationStructuresPropertiesKHR(m_device, | |
| accelerationStructures.size(), | |
| reinterpret_cast<const VkAccelerationStructureKHR *>(accelerationStructures.data()), | |
| static_cast<VkQueryType>(queryType), | |
| data.size() * sizeof(DataType), | |
| reinterpret_cast<void *>(data.data()), | |
| stride)); | |
| return createResultValue(result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::writeAccelerationStructuresPropertiesKHR"); | |
| } | |
| template<typename DataType, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<DataType>::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); | |
| DataType data; | |
| VkResult result = d.vkWriteAccelerationStructuresPropertiesKHR(m_device, | |
| accelerationStructures.size(), | |
| reinterpret_cast<const VkAccelerationStructureKHR *>(accelerationStructures.data()), | |
| static_cast<VkQueryType>(queryType), | |
| sizeof(DataType), | |
| reinterpret_cast<void *>(&data), | |
| stride); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::writeAccelerationStructuresPropertyKHR"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), data); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureKHR(const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR *pInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdCopyAccelerationStructureKHR(m_commandBuffer, reinterpret_cast<const VkCopyAccelerationStructureInfoKHR *>(pInfo)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureKHR(const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR &info, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdCopyAccelerationStructureKHR(m_commandBuffer, reinterpret_cast<const VkCopyAccelerationStructureInfoKHR *>(&info)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureToMemoryKHR(const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR *pInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdCopyAccelerationStructureToMemoryKHR(m_commandBuffer, reinterpret_cast<const VkCopyAccelerationStructureToMemoryInfoKHR *>(pInfo)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureToMemoryKHR(const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR &info, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdCopyAccelerationStructureToMemoryKHR(m_commandBuffer, reinterpret_cast<const VkCopyAccelerationStructureToMemoryInfoKHR *>(&info)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::copyMemoryToAccelerationStructureKHR(const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR *pInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdCopyMemoryToAccelerationStructureKHR(m_commandBuffer, reinterpret_cast<const VkCopyMemoryToAccelerationStructureInfoKHR *>(pInfo)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::copyMemoryToAccelerationStructureKHR(const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR &info, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdCopyMemoryToAccelerationStructureKHR(m_commandBuffer, reinterpret_cast<const VkCopyMemoryToAccelerationStructureInfoKHR *>(&info)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE DeviceAddress Device::getAccelerationStructureAddressKHR(const VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR *pInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<DeviceAddress>( | |
| d.vkGetAccelerationStructureDeviceAddressKHR(m_device, reinterpret_cast<const VkAccelerationStructureDeviceAddressInfoKHR *>(pInfo))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceAddress | |
| Device::getAccelerationStructureAddressKHR(const VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR &info, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VkDeviceAddress result = | |
| d.vkGetAccelerationStructureDeviceAddressKHR(m_device, reinterpret_cast<const VkAccelerationStructureDeviceAddressInfoKHR *>(&info)); | |
| return static_cast<VULKAN_HPP_NAMESPACE::DeviceAddress>(result); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::writeAccelerationStructuresPropertiesKHR(uint32_t accelerationStructureCount, | |
| const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR *pAccelerationStructures, | |
| VULKAN_HPP_NAMESPACE::QueryType queryType, | |
| VULKAN_HPP_NAMESPACE::QueryPool queryPool, | |
| uint32_t firstQuery, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdWriteAccelerationStructuresPropertiesKHR(m_commandBuffer, | |
| accelerationStructureCount, | |
| reinterpret_cast<const VkAccelerationStructureKHR *>(pAccelerationStructures), | |
| static_cast<VkQueryType>(queryType), | |
| static_cast<VkQueryPool>(queryPool), | |
| firstQuery); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::writeAccelerationStructuresPropertiesKHR(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 VULKAN_HPP_NAMESPACE::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 VULKAN_HPP_NAMESPACE::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 VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>::type | |
| Device::createSamplerYcbcrConversionKHR(const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion; | |
| VkResult 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)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::createSamplerYcbcrConversionKHR"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), ycbcrConversion); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion, Dispatch>>::type | |
| Device::createSamplerYcbcrConversionKHRUnique(const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| 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 VULKAN_HPP_NAMESPACE::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); | |
| VkResult result = d.vkBindBufferMemory2KHR(m_device, bindInfos.size(), reinterpret_cast<const VkBindBufferMemoryInfo *>(bindInfos.data())); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::bindBufferMemory2KHR"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::bindImageMemory2KHR(uint32_t bindInfoCount, | |
| const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo *pBindInfos, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkBindImageMemory2KHR(m_device, bindInfoCount, reinterpret_cast<const VkBindImageMemoryInfo *>(pBindInfos))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| Device::bindImageMemory2KHR(ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const &bindInfos, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VkResult result = d.vkBindImageMemory2KHR(m_device, bindInfos.size(), reinterpret_cast<const VkBindImageMemoryInfo *>(bindInfos.data())); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::bindImageMemory2KHR"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_EXT_image_drm_format_modifier === | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getImageDrmFormatModifierPropertiesEXT( | |
| VULKAN_HPP_NAMESPACE::Image image, VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT *pProperties, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkGetImageDrmFormatModifierPropertiesEXT( | |
| m_device, static_cast<VkImage>(image), reinterpret_cast<VkImageDrmFormatModifierPropertiesEXT *>(pProperties))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT>::type | |
| Device::getImageDrmFormatModifierPropertiesEXT(VULKAN_HPP_NAMESPACE::Image image, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT properties; | |
| VkResult result = d.vkGetImageDrmFormatModifierPropertiesEXT( | |
| m_device, static_cast<VkImage>(image), reinterpret_cast<VkImageDrmFormatModifierPropertiesEXT *>(&properties)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::getImageDrmFormatModifierPropertiesEXT"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), properties); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_EXT_validation_cache === | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createValidationCacheEXT(const VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT *pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| VULKAN_HPP_NAMESPACE::ValidationCacheEXT *pValidationCache, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkCreateValidationCacheEXT(m_device, | |
| reinterpret_cast<const VkValidationCacheCreateInfoEXT *>(pCreateInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(pAllocator), | |
| reinterpret_cast<VkValidationCacheEXT *>(pValidationCache))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::ValidationCacheEXT>::type | |
| Device::createValidationCacheEXT(const VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache; | |
| VkResult 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)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::createValidationCacheEXT"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), validationCache); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ValidationCacheEXT, Dispatch>>::type | |
| Device::createValidationCacheEXTUnique(const VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| 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 VULKAN_HPP_NAMESPACE::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 VULKAN_HPP_NAMESPACE::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); | |
| VkResult result = d.vkMergeValidationCachesEXT( | |
| m_device, static_cast<VkValidationCacheEXT>(dstCache), srcCaches.size(), reinterpret_cast<const VkValidationCacheEXT *>(srcCaches.data())); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::mergeValidationCachesEXT"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getValidationCacheDataEXT(VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache, | |
| size_t *pDataSize, | |
| void *pData, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkGetValidationCacheDataEXT(m_device, static_cast<VkValidationCacheEXT>(validationCache), pDataSize, pData)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Uint8_tAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type | |
| Device::getValidationCacheDataEXT(VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| 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()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(dataSize <= data.size()); | |
| if(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()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(dataSize <= data.size()); | |
| if(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_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::AccelerationStructureNV>::type | |
| Device::createAccelerationStructureNV(const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure; | |
| VkResult 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)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::createAccelerationStructureNV"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), accelerationStructure); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::AccelerationStructureNV, Dispatch>>::type | |
| Device::createAccelerationStructureNVUnique(const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| 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 VULKAN_HPP_NAMESPACE::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 VULKAN_HPP_NAMESPACE::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 VULKAN_HPP_NAMESPACE::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 VULKAN_HPP_NAMESPACE::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); | |
| VkResult result = d.vkBindAccelerationStructureMemoryNV( | |
| m_device, bindInfos.size(), reinterpret_cast<const VkBindAccelerationStructureMemoryInfoNV *>(bindInfos.data())); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::bindAccelerationStructureMemoryNV"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructureNV(const VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV *pInfo, | |
| VULKAN_HPP_NAMESPACE::Buffer instanceData, | |
| VULKAN_HPP_NAMESPACE::DeviceSize instanceOffset, | |
| VULKAN_HPP_NAMESPACE::Bool32 update, | |
| VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst, | |
| VULKAN_HPP_NAMESPACE::AccelerationStructureNV src, | |
| VULKAN_HPP_NAMESPACE::Buffer scratch, | |
| VULKAN_HPP_NAMESPACE::DeviceSize scratchOffset, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdBuildAccelerationStructureNV(m_commandBuffer, | |
| reinterpret_cast<const VkAccelerationStructureInfoNV *>(pInfo), | |
| static_cast<VkBuffer>(instanceData), | |
| static_cast<VkDeviceSize>(instanceOffset), | |
| static_cast<VkBool32>(update), | |
| static_cast<VkAccelerationStructureNV>(dst), | |
| static_cast<VkAccelerationStructureNV>(src), | |
| static_cast<VkBuffer>(scratch), | |
| static_cast<VkDeviceSize>(scratchOffset)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructureNV(const VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV &info, | |
| VULKAN_HPP_NAMESPACE::Buffer instanceData, | |
| VULKAN_HPP_NAMESPACE::DeviceSize instanceOffset, | |
| VULKAN_HPP_NAMESPACE::Bool32 update, | |
| VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst, | |
| VULKAN_HPP_NAMESPACE::AccelerationStructureNV src, | |
| VULKAN_HPP_NAMESPACE::Buffer scratch, | |
| VULKAN_HPP_NAMESPACE::DeviceSize scratchOffset, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdBuildAccelerationStructureNV(m_commandBuffer, | |
| reinterpret_cast<const VkAccelerationStructureInfoNV *>(&info), | |
| static_cast<VkBuffer>(instanceData), | |
| static_cast<VkDeviceSize>(instanceOffset), | |
| static_cast<VkBool32>(update), | |
| static_cast<VkAccelerationStructureNV>(dst), | |
| static_cast<VkAccelerationStructureNV>(src), | |
| static_cast<VkBuffer>(scratch), | |
| static_cast<VkDeviceSize>(scratchOffset)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureNV(VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst, | |
| VULKAN_HPP_NAMESPACE::AccelerationStructureNV src, | |
| VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR mode, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdCopyAccelerationStructureNV(m_commandBuffer, | |
| static_cast<VkAccelerationStructureNV>(dst), | |
| static_cast<VkAccelerationStructureNV>(src), | |
| static_cast<VkCopyAccelerationStructureModeKHR>(mode)); | |
| } | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::traceRaysNV(VULKAN_HPP_NAMESPACE::Buffer raygenShaderBindingTableBuffer, | |
| VULKAN_HPP_NAMESPACE::DeviceSize raygenShaderBindingOffset, | |
| VULKAN_HPP_NAMESPACE::Buffer missShaderBindingTableBuffer, | |
| VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingOffset, | |
| VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingStride, | |
| VULKAN_HPP_NAMESPACE::Buffer hitShaderBindingTableBuffer, | |
| VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingOffset, | |
| VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingStride, | |
| VULKAN_HPP_NAMESPACE::Buffer callableShaderBindingTableBuffer, | |
| VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingOffset, | |
| VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingStride, | |
| uint32_t width, | |
| uint32_t height, | |
| uint32_t depth, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdTraceRaysNV(m_commandBuffer, | |
| static_cast<VkBuffer>(raygenShaderBindingTableBuffer), | |
| static_cast<VkDeviceSize>(raygenShaderBindingOffset), | |
| static_cast<VkBuffer>(missShaderBindingTableBuffer), | |
| static_cast<VkDeviceSize>(missShaderBindingOffset), | |
| static_cast<VkDeviceSize>(missShaderBindingStride), | |
| static_cast<VkBuffer>(hitShaderBindingTableBuffer), | |
| static_cast<VkDeviceSize>(hitShaderBindingOffset), | |
| static_cast<VkDeviceSize>(hitShaderBindingStride), | |
| static_cast<VkBuffer>(callableShaderBindingTableBuffer), | |
| static_cast<VkDeviceSize>(callableShaderBindingOffset), | |
| static_cast<VkDeviceSize>(callableShaderBindingStride), | |
| width, | |
| height, | |
| depth); | |
| } | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createRayTracingPipelinesNV(VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| uint32_t createInfoCount, | |
| const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV *pCreateInfos, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| VULKAN_HPP_NAMESPACE::Pipeline *pPipelines, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkCreateRayTracingPipelinesNV(m_device, | |
| static_cast<VkPipelineCache>(pipelineCache), | |
| createInfoCount, | |
| reinterpret_cast<const VkRayTracingPipelineCreateInfoNV *>(pCreateInfos), | |
| reinterpret_cast<const VkAllocationCallbacks *>(pAllocator), | |
| reinterpret_cast<VkPipeline *>(pPipelines))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename PipelineAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>> | |
| Device::createRayTracingPipelinesNV(VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const &createInfos, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator> pipelines(createInfos.size()); | |
| VkResult 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())); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesNV", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT }); | |
| return ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), pipelines); | |
| } | |
| template<typename PipelineAllocator, | |
| typename Dispatch, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, Pipeline>::value, int>::type> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>> | |
| Device::createRayTracingPipelinesNV(VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const &createInfos, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| PipelineAllocator &pipelineAllocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator> pipelines(createInfos.size(), pipelineAllocator); | |
| VkResult 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())); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesNV", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT }); | |
| return ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), pipelines); | |
| } | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<VULKAN_HPP_NAMESPACE::Pipeline> | |
| Device::createRayTracingPipelineNV(VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::Pipeline pipeline; | |
| VkResult 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)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelineNV", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT }); | |
| return ResultValue<VULKAN_HPP_NAMESPACE::Pipeline>(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), pipeline); | |
| } | |
| # 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 VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator> uniquePipelines; | |
| std::vector<Pipeline> pipelines(createInfos.size()); | |
| Result result = static_cast<Result>(d.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 VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| PipelineAllocator &pipelineAllocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator> uniquePipelines(pipelineAllocator); | |
| std::vector<Pipeline> pipelines(createInfos.size()); | |
| Result result = static_cast<Result>(d.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 VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| Pipeline pipeline; | |
| Result result = static_cast<Result>(d.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 DataType, typename DataTypeAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type Device::getRayTracingShaderGroupHandlesNV( | |
| VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_ASSERT(dataSize % sizeof(DataType) == 0); | |
| std::vector<DataType, DataTypeAllocator> data(dataSize / sizeof(DataType)); | |
| Result result = static_cast<Result>(d.vkGetRayTracingShaderGroupHandlesNV( | |
| m_device, static_cast<VkPipeline>(pipeline), firstGroup, groupCount, data.size() * sizeof(DataType), reinterpret_cast<void *>(data.data()))); | |
| return createResultValue(result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandlesNV"); | |
| } | |
| template<typename DataType, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<DataType>::type | |
| Device::getRayTracingShaderGroupHandleNV(VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| DataType data; | |
| VkResult result = d.vkGetRayTracingShaderGroupHandlesNV( | |
| m_device, static_cast<VkPipeline>(pipeline), firstGroup, groupCount, sizeof(DataType), reinterpret_cast<void *>(&data)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandleNV"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), data); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getAccelerationStructureHandleNV(VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure, | |
| size_t dataSize, | |
| void *pData, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>( | |
| d.vkGetAccelerationStructureHandleNV(m_device, static_cast<VkAccelerationStructureNV>(accelerationStructure), dataSize, pData)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename DataType, typename DataTypeAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type | |
| Device::getAccelerationStructureHandleNV(VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure, size_t dataSize, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_ASSERT(dataSize % sizeof(DataType) == 0); | |
| std::vector<DataType, DataTypeAllocator> data(dataSize / sizeof(DataType)); | |
| Result result = static_cast<Result>(d.vkGetAccelerationStructureHandleNV( | |
| m_device, static_cast<VkAccelerationStructureNV>(accelerationStructure), data.size() * sizeof(DataType), reinterpret_cast<void *>(data.data()))); | |
| return createResultValue(result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getAccelerationStructureHandleNV"); | |
| } | |
| template<typename DataType, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<DataType>::type | |
| Device::getAccelerationStructureHandleNV(VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| DataType data; | |
| VkResult result = d.vkGetAccelerationStructureHandleNV( | |
| m_device, static_cast<VkAccelerationStructureNV>(accelerationStructure), sizeof(DataType), reinterpret_cast<void *>(&data)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::getAccelerationStructureHandleNV"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), data); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesNV(uint32_t accelerationStructureCount, | |
| const VULKAN_HPP_NAMESPACE::AccelerationStructureNV *pAccelerationStructures, | |
| VULKAN_HPP_NAMESPACE::QueryType queryType, | |
| VULKAN_HPP_NAMESPACE::QueryPool queryPool, | |
| uint32_t firstQuery, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdWriteAccelerationStructuresPropertiesNV(m_commandBuffer, | |
| accelerationStructureCount, | |
| reinterpret_cast<const VkAccelerationStructureNV *>(pAccelerationStructures), | |
| static_cast<VkQueryType>(queryType), | |
| static_cast<VkQueryPool>(queryPool), | |
| firstQuery); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::writeAccelerationStructuresPropertiesNV(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); | |
| VkResult result = d.vkCompileDeferredNV(m_device, static_cast<VkPipeline>(pipeline), shader); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::compileDeferredNV"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_KHR_maintenance3 === | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::getDescriptorSetLayoutSupportKHR(const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo *pCreateInfo, | |
| VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport *pSupport, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkGetDescriptorSetLayoutSupportKHR( | |
| m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>(pCreateInfo), reinterpret_cast<VkDescriptorSetLayoutSupport *>(pSupport)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport | |
| Device::getDescriptorSetLayoutSupportKHR(const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo &createInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| 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 VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo &createInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| StructureChain<X, Y, Z...> structureChain; | |
| VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport &support = structureChain.template get<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport>(); | |
| d.vkGetDescriptorSetLayoutSupportKHR( | |
| m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>(&createInfo), reinterpret_cast<VkDescriptorSetLayoutSupport *>(&support)); | |
| return structureChain; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_KHR_draw_indirect_count === | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountKHR(VULKAN_HPP_NAMESPACE::Buffer buffer, | |
| VULKAN_HPP_NAMESPACE::DeviceSize offset, | |
| VULKAN_HPP_NAMESPACE::Buffer countBuffer, | |
| VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, | |
| uint32_t maxDrawCount, | |
| uint32_t stride, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdDrawIndirectCountKHR(m_commandBuffer, | |
| static_cast<VkBuffer>(buffer), | |
| static_cast<VkDeviceSize>(offset), | |
| static_cast<VkBuffer>(countBuffer), | |
| static_cast<VkDeviceSize>(countBufferOffset), | |
| maxDrawCount, | |
| stride); | |
| } | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountKHR(VULKAN_HPP_NAMESPACE::Buffer buffer, | |
| VULKAN_HPP_NAMESPACE::DeviceSize offset, | |
| VULKAN_HPP_NAMESPACE::Buffer countBuffer, | |
| VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, | |
| uint32_t maxDrawCount, | |
| uint32_t stride, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdDrawIndexedIndirectCountKHR(m_commandBuffer, | |
| static_cast<VkBuffer>(buffer), | |
| static_cast<VkDeviceSize>(offset), | |
| static_cast<VkBuffer>(countBuffer), | |
| static_cast<VkDeviceSize>(countBufferOffset), | |
| maxDrawCount, | |
| stride); | |
| } | |
| //=== VK_EXT_external_memory_host === | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::getMemoryHostPointerPropertiesEXT(VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, | |
| const void *pHostPointer, | |
| VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT *pMemoryHostPointerProperties, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkGetMemoryHostPointerPropertiesEXT(m_device, | |
| static_cast<VkExternalMemoryHandleTypeFlagBits>(handleType), | |
| pHostPointer, | |
| reinterpret_cast<VkMemoryHostPointerPropertiesEXT *>(pMemoryHostPointerProperties))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT>::type | |
| Device::getMemoryHostPointerPropertiesEXT(VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, | |
| const void *pHostPointer, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT memoryHostPointerProperties; | |
| VkResult result = d.vkGetMemoryHostPointerPropertiesEXT(m_device, | |
| static_cast<VkExternalMemoryHandleTypeFlagBits>(handleType), | |
| pHostPointer, | |
| reinterpret_cast<VkMemoryHostPointerPropertiesEXT *>(&memoryHostPointerProperties)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryHostPointerPropertiesEXT"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), memoryHostPointerProperties); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_AMD_buffer_marker === | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::writeBufferMarkerAMD(VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage, | |
| VULKAN_HPP_NAMESPACE::Buffer dstBuffer, | |
| VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, | |
| uint32_t marker, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdWriteBufferMarkerAMD(m_commandBuffer, | |
| static_cast<VkPipelineStageFlagBits>(pipelineStage), | |
| static_cast<VkBuffer>(dstBuffer), | |
| static_cast<VkDeviceSize>(dstOffset), | |
| marker); | |
| } | |
| //=== VK_EXT_calibrated_timestamps === | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getCalibrateableTimeDomainsEXT(uint32_t *pTimeDomainCount, | |
| VULKAN_HPP_NAMESPACE::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()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(timeDomainCount <= timeDomains.size()); | |
| if(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()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(timeDomainCount <= timeDomains.size()); | |
| if(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 Uint64_tAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type | |
| Device::getCalibratedTimestampsEXT(ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT> const ×tampInfos, 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> ×tamps = 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 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 ×tampInfos, | |
| 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> ×tamps = 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 Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::pair<uint64_t, uint64_t>>::type | |
| Device::getCalibratedTimestampEXT(const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT ×tampInfo, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| std::pair<uint64_t, uint64_t> data; | |
| uint64_t ×tamp = data.first; | |
| uint64_t &maxDeviation = data.second; | |
| Result result = static_cast<Result>( | |
| d.vkGetCalibratedTimestampsEXT(m_device, 1, reinterpret_cast<const VkCalibratedTimestampInfoEXT *>(×tampInfo), ×tamp, &maxDeviation)); | |
| return createResultValue(result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampEXT"); | |
| } | |
| #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); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename CheckpointMarkerType, typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setCheckpointNV(CheckpointMarkerType const &checkpointMarker, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdSetCheckpointNV(m_commandBuffer, reinterpret_cast<const void *>(&checkpointMarker)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Queue::getCheckpointDataNV(uint32_t *pCheckpointDataCount, | |
| VULKAN_HPP_NAMESPACE::CheckpointDataNV *pCheckpointData, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkGetQueueCheckpointDataNV(m_queue, pCheckpointDataCount, reinterpret_cast<VkCheckpointDataNV *>(pCheckpointData)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename CheckpointDataNVAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<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 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; | |
| VkResult result = d.vkGetSemaphoreCounterValueKHR(m_device, static_cast<VkSemaphore>(semaphore), &value); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreCounterValueKHR"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), value); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::waitSemaphoresKHR(const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo *pWaitInfo, | |
| uint64_t timeout, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkWaitSemaphoresKHR(m_device, reinterpret_cast<const VkSemaphoreWaitInfo *>(pWaitInfo), timeout)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result | |
| Device::waitSemaphoresKHR(const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo &waitInfo, uint64_t timeout, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VkResult result = d.vkWaitSemaphoresKHR(m_device, reinterpret_cast<const VkSemaphoreWaitInfo *>(&waitInfo), timeout); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::waitSemaphoresKHR", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eTimeout }); | |
| return static_cast<VULKAN_HPP_NAMESPACE::Result>(result); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::signalSemaphoreKHR(const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo *pSignalInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkSignalSemaphoreKHR(m_device, reinterpret_cast<const VkSemaphoreSignalInfo *>(pSignalInfo))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| Device::signalSemaphoreKHR(const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo &signalInfo, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VkResult result = d.vkSignalSemaphoreKHR(m_device, reinterpret_cast<const VkSemaphoreSignalInfo *>(&signalInfo)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::signalSemaphoreKHR"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_INTEL_performance_query === | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::initializePerformanceApiINTEL( | |
| const VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL *pInitializeInfo, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>( | |
| d.vkInitializePerformanceApiINTEL(m_device, reinterpret_cast<const VkInitializePerformanceApiInfoINTEL *>(pInitializeInfo))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| Device::initializePerformanceApiINTEL(const VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL &initializeInfo, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VkResult result = d.vkInitializePerformanceApiINTEL(m_device, reinterpret_cast<const VkInitializePerformanceApiInfoINTEL *>(&initializeInfo)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::initializePerformanceApiINTEL"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::uninitializePerformanceApiINTEL(Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkUninitializePerformanceApiINTEL(m_device); | |
| } | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result CommandBuffer::setPerformanceMarkerINTEL(const VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL *pMarkerInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkCmdSetPerformanceMarkerINTEL(m_commandBuffer, reinterpret_cast<const VkPerformanceMarkerInfoINTEL *>(pMarkerInfo))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| CommandBuffer::setPerformanceMarkerINTEL(const VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL &markerInfo, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VkResult result = d.vkCmdSetPerformanceMarkerINTEL(m_commandBuffer, reinterpret_cast<const VkPerformanceMarkerInfoINTEL *>(&markerInfo)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::setPerformanceMarkerINTEL"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result CommandBuffer::setPerformanceStreamMarkerINTEL( | |
| const VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL *pMarkerInfo, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>( | |
| d.vkCmdSetPerformanceStreamMarkerINTEL(m_commandBuffer, reinterpret_cast<const VkPerformanceStreamMarkerInfoINTEL *>(pMarkerInfo))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| CommandBuffer::setPerformanceStreamMarkerINTEL(const VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL &markerInfo, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VkResult result = d.vkCmdSetPerformanceStreamMarkerINTEL(m_commandBuffer, reinterpret_cast<const VkPerformanceStreamMarkerInfoINTEL *>(&markerInfo)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::setPerformanceStreamMarkerINTEL"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result CommandBuffer::setPerformanceOverrideINTEL( | |
| const VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL *pOverrideInfo, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>( | |
| d.vkCmdSetPerformanceOverrideINTEL(m_commandBuffer, reinterpret_cast<const VkPerformanceOverrideInfoINTEL *>(pOverrideInfo))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| CommandBuffer::setPerformanceOverrideINTEL(const VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL &overrideInfo, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VkResult result = d.vkCmdSetPerformanceOverrideINTEL(m_commandBuffer, reinterpret_cast<const VkPerformanceOverrideInfoINTEL *>(&overrideInfo)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::setPerformanceOverrideINTEL"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::acquirePerformanceConfigurationINTEL(const VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL *pAcquireInfo, | |
| VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL *pConfiguration, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkAcquirePerformanceConfigurationINTEL(m_device, | |
| reinterpret_cast<const VkPerformanceConfigurationAcquireInfoINTEL *>(pAcquireInfo), | |
| reinterpret_cast<VkPerformanceConfigurationINTEL *>(pConfiguration))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL>::type | |
| Device::acquirePerformanceConfigurationINTEL(const VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL &acquireInfo, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration; | |
| VkResult result = d.vkAcquirePerformanceConfigurationINTEL(m_device, | |
| reinterpret_cast<const VkPerformanceConfigurationAcquireInfoINTEL *>(&acquireInfo), | |
| reinterpret_cast<VkPerformanceConfigurationINTEL *>(&configuration)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::acquirePerformanceConfigurationINTEL"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), configuration); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL, Dispatch>>::type | |
| Device::acquirePerformanceConfigurationINTELUnique(const VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL &acquireInfo, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| 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); | |
| VkResult result = d.vkReleasePerformanceConfigurationINTEL(m_device, static_cast<VkPerformanceConfigurationINTEL>(configuration)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::releasePerformanceConfigurationINTEL"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::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); | |
| VkResult result = d.vkReleasePerformanceConfigurationINTEL(m_device, static_cast<VkPerformanceConfigurationINTEL>(configuration)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::release"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result 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); | |
| VkResult result = d.vkQueueSetPerformanceConfigurationINTEL(m_queue, static_cast<VkPerformanceConfigurationINTEL>(configuration)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Queue::setPerformanceConfigurationINTEL"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getPerformanceParameterINTEL(VULKAN_HPP_NAMESPACE::PerformanceParameterTypeINTEL parameter, | |
| VULKAN_HPP_NAMESPACE::PerformanceValueINTEL *pValue, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkGetPerformanceParameterINTEL( | |
| m_device, static_cast<VkPerformanceParameterTypeINTEL>(parameter), reinterpret_cast<VkPerformanceValueINTEL *>(pValue))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::PerformanceValueINTEL>::type | |
| Device::getPerformanceParameterINTEL(VULKAN_HPP_NAMESPACE::PerformanceParameterTypeINTEL parameter, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::PerformanceValueINTEL value; | |
| VkResult result = d.vkGetPerformanceParameterINTEL( | |
| m_device, static_cast<VkPerformanceParameterTypeINTEL>(parameter), reinterpret_cast<VkPerformanceValueINTEL *>(&value)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::getPerformanceParameterINTEL"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), value); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_AMD_display_native_hdr === | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::setLocalDimmingAMD(VULKAN_HPP_NAMESPACE::SwapchainKHR swapChain, | |
| VULKAN_HPP_NAMESPACE::Bool32 localDimmingEnable, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkSetLocalDimmingAMD(m_device, static_cast<VkSwapchainKHR>(swapChain), static_cast<VkBool32>(localDimmingEnable)); | |
| } | |
| #if defined(VK_USE_PLATFORM_FUCHSIA) | |
| //=== VK_FUCHSIA_imagepipe_surface === | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Instance::createImagePipeSurfaceFUCHSIA(const VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA *pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| VULKAN_HPP_NAMESPACE::SurfaceKHR *pSurface, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkCreateImagePipeSurfaceFUCHSIA(m_instance, | |
| reinterpret_cast<const VkImagePipeSurfaceCreateInfoFUCHSIA *>(pCreateInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(pAllocator), | |
| reinterpret_cast<VkSurfaceKHR *>(pSurface))); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type | |
| Instance::createImagePipeSurfaceFUCHSIA(const VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface; | |
| VkResult 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)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Instance::createImagePipeSurfaceFUCHSIA"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), surface); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type | |
| Instance::createImagePipeSurfaceFUCHSIAUnique(const VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| 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 VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type | |
| Instance::createMetalSurfaceEXT(const VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface; | |
| VkResult 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)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Instance::createMetalSurfaceEXT"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), surface); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type | |
| Instance::createMetalSurfaceEXTUnique(const VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| 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()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(fragmentShadingRateCount <= fragmentShadingRates.size()); | |
| if(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()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(fragmentShadingRateCount <= fragmentShadingRates.size()); | |
| if(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 VULKAN_HPP_NAMESPACE::Extent2D &fragmentSize, | |
| const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2], | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| 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 VULKAN_HPP_NAMESPACE::DeviceAddress Device::getBufferAddressEXT(const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo &info, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VkDeviceAddress result = d.vkGetBufferDeviceAddressEXT(m_device, reinterpret_cast<const VkBufferDeviceAddressInfo *>(&info)); | |
| return static_cast<VULKAN_HPP_NAMESPACE::DeviceAddress>(result); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_EXT_tooling_info === | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getToolPropertiesEXT(uint32_t *pToolCount, | |
| VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties *pToolProperties, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>( | |
| d.vkGetPhysicalDeviceToolPropertiesEXT(m_physicalDevice, pToolCount, reinterpret_cast<VkPhysicalDeviceToolProperties *>(pToolProperties))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename PhysicalDeviceToolPropertiesAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator>>::type | |
| PhysicalDevice::getToolPropertiesEXT(Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| std::vector<PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator> 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<VkPhysicalDeviceToolProperties *>(toolProperties.data()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(toolCount <= toolProperties.size()); | |
| if(toolCount < toolProperties.size()) | |
| { | |
| toolProperties.resize(toolCount); | |
| } | |
| } | |
| return createResultValue(result, toolProperties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getToolPropertiesEXT"); | |
| } | |
| template<typename PhysicalDeviceToolPropertiesAllocator, | |
| typename Dispatch, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, PhysicalDeviceToolProperties>::value, int>::type> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator>>::type | |
| PhysicalDevice::getToolPropertiesEXT(PhysicalDeviceToolPropertiesAllocator &physicalDeviceToolPropertiesAllocator, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| std::vector<PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator> toolProperties(physicalDeviceToolPropertiesAllocator); | |
| 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<VkPhysicalDeviceToolProperties *>(toolProperties.data()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(toolCount <= toolProperties.size()); | |
| if(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 VULKAN_HPP_NAMESPACE::Result | |
| Device::waitForPresentKHR(VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, uint64_t presentId, uint64_t timeout, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VkResult result = d.vkWaitForPresentKHR(m_device, static_cast<VkSwapchainKHR>(swapchain), presentId, timeout); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::waitForPresentKHR", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eTimeout, VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR }); | |
| return static_cast<VULKAN_HPP_NAMESPACE::Result>(result); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_NV_cooperative_matrix === | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getCooperativeMatrixPropertiesNV( | |
| uint32_t *pPropertyCount, VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV *pProperties, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( | |
| m_physicalDevice, pPropertyCount, reinterpret_cast<VkCooperativeMatrixPropertiesNV *>(pProperties))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename CooperativeMatrixPropertiesNVAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<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()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(propertyCount <= properties.size()); | |
| if(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()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(propertyCount <= properties.size()); | |
| if(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()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(combinationCount <= combinations.size()); | |
| if(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()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(combinationCount <= combinations.size()); | |
| if(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 VULKAN_HPP_NAMESPACE::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()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(presentModeCount <= presentModes.size()); | |
| if(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 VULKAN_HPP_NAMESPACE::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()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(presentModeCount <= presentModes.size()); | |
| if(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); | |
| VkResult result = d.vkAcquireFullScreenExclusiveModeEXT(m_device, static_cast<VkSwapchainKHR>(swapchain)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::acquireFullScreenExclusiveModeEXT"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result)); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| # ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::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); | |
| VkResult result = d.vkReleaseFullScreenExclusiveModeEXT(m_device, static_cast<VkSwapchainKHR>(swapchain)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::releaseFullScreenExclusiveModeEXT"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result)); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::getGroupSurfacePresentModes2EXT(const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, | |
| VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR *pModes, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkGetDeviceGroupSurfacePresentModes2EXT( | |
| m_device, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>(pSurfaceInfo), reinterpret_cast<VkDeviceGroupPresentModeFlagsKHR *>(pModes))); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR>::type | |
| Device::getGroupSurfacePresentModes2EXT(const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR &surfaceInfo, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR modes; | |
| VkResult result = d.vkGetDeviceGroupSurfacePresentModes2EXT( | |
| m_device, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>(&surfaceInfo), reinterpret_cast<VkDeviceGroupPresentModeFlagsKHR *>(&modes)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::getGroupSurfacePresentModes2EXT"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), modes); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #endif /*VK_USE_PLATFORM_WIN32_KHR*/ | |
| //=== VK_EXT_headless_surface === | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createHeadlessSurfaceEXT(const VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT *pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| VULKAN_HPP_NAMESPACE::SurfaceKHR *pSurface, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkCreateHeadlessSurfaceEXT(m_instance, | |
| reinterpret_cast<const VkHeadlessSurfaceCreateInfoEXT *>(pCreateInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(pAllocator), | |
| reinterpret_cast<VkSurfaceKHR *>(pSurface))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type | |
| Instance::createHeadlessSurfaceEXT(const VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface; | |
| VkResult 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)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Instance::createHeadlessSurfaceEXT"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), surface); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type | |
| Instance::createHeadlessSurfaceEXTUnique(const VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| 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 VULKAN_HPP_NAMESPACE::DeviceAddress Device::getBufferAddressKHR(const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo &info, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VkDeviceAddress result = d.vkGetBufferDeviceAddressKHR(m_device, reinterpret_cast<const VkBufferDeviceAddressInfo *>(&info)); | |
| return static_cast<VULKAN_HPP_NAMESPACE::DeviceAddress>(result); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE uint64_t Device::getBufferOpaqueCaptureAddressKHR(const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo *pInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return d.vkGetBufferOpaqueCaptureAddressKHR(m_device, reinterpret_cast<const VkBufferDeviceAddressInfo *>(pInfo)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE uint64_t Device::getBufferOpaqueCaptureAddressKHR(const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo &info, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| uint64_t result = d.vkGetBufferOpaqueCaptureAddressKHR(m_device, reinterpret_cast<const VkBufferDeviceAddressInfo *>(&info)); | |
| return result; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE uint64_t Device::getMemoryOpaqueCaptureAddressKHR(const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo *pInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return d.vkGetDeviceMemoryOpaqueCaptureAddressKHR(m_device, reinterpret_cast<const VkDeviceMemoryOpaqueCaptureAddressInfo *>(pInfo)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE uint64_t Device::getMemoryOpaqueCaptureAddressKHR(const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo &info, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| uint64_t result = d.vkGetDeviceMemoryOpaqueCaptureAddressKHR(m_device, reinterpret_cast<const VkDeviceMemoryOpaqueCaptureAddressInfo *>(&info)); | |
| return result; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_EXT_line_rasterization === | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| CommandBuffer::setLineStippleEXT(uint32_t lineStippleFactor, uint16_t lineStipplePattern, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdSetLineStippleEXT(m_commandBuffer, lineStippleFactor, lineStipplePattern); | |
| } | |
| //=== VK_EXT_host_query_reset === | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::resetQueryPoolEXT(VULKAN_HPP_NAMESPACE::QueryPool queryPool, | |
| uint32_t firstQuery, | |
| uint32_t queryCount, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkResetQueryPoolEXT(m_device, static_cast<VkQueryPool>(queryPool), firstQuery, queryCount); | |
| } | |
| //=== VK_EXT_extended_dynamic_state === | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setCullModeEXT(VULKAN_HPP_NAMESPACE::CullModeFlags cullMode, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdSetCullModeEXT(m_commandBuffer, static_cast<VkCullModeFlags>(cullMode)); | |
| } | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setFrontFaceEXT(VULKAN_HPP_NAMESPACE::FrontFace frontFace, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdSetFrontFaceEXT(m_commandBuffer, static_cast<VkFrontFace>(frontFace)); | |
| } | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setPrimitiveTopologyEXT(VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdSetPrimitiveTopologyEXT(m_commandBuffer, static_cast<VkPrimitiveTopology>(primitiveTopology)); | |
| } | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setViewportWithCountEXT(uint32_t viewportCount, | |
| const VULKAN_HPP_NAMESPACE::Viewport *pViewports, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdSetViewportWithCountEXT(m_commandBuffer, viewportCount, reinterpret_cast<const VkViewport *>(pViewports)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setViewportWithCountEXT(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_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::DeferredOperationKHR>::type | |
| Device::createDeferredOperationKHR(Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation; | |
| VkResult result = d.vkCreateDeferredOperationKHR( | |
| m_device, | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)), | |
| reinterpret_cast<VkDeferredOperationKHR *>(&deferredOperation)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::createDeferredOperationKHR"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), deferredOperation); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DeferredOperationKHR, Dispatch>>::type | |
| Device::createDeferredOperationKHRUnique(Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| 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 VULKAN_HPP_NAMESPACE::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 VULKAN_HPP_NAMESPACE::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 VULKAN_HPP_NAMESPACE::Result | |
| Device::getDeferredOperationResultKHR(VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VkResult result = d.vkGetDeferredOperationResultKHR(m_device, static_cast<VkDeferredOperationKHR>(operation)); | |
| return static_cast<VULKAN_HPP_NAMESPACE::Result>(result); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::deferredOperationJoinKHR(VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkDeferredOperationJoinKHR(m_device, static_cast<VkDeferredOperationKHR>(operation))); | |
| } | |
| #else | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result Device::deferredOperationJoinKHR(VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VkResult result = d.vkDeferredOperationJoinKHR(m_device, static_cast<VkDeferredOperationKHR>(operation)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::deferredOperationJoinKHR", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eThreadDoneKHR, VULKAN_HPP_NAMESPACE::Result::eThreadIdleKHR }); | |
| return static_cast<VULKAN_HPP_NAMESPACE::Result>(result); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_KHR_pipeline_executable_properties === | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getPipelineExecutablePropertiesKHR(const VULKAN_HPP_NAMESPACE::PipelineInfoKHR *pPipelineInfo, | |
| uint32_t *pExecutableCount, | |
| VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR *pProperties, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkGetPipelineExecutablePropertiesKHR(m_device, | |
| reinterpret_cast<const VkPipelineInfoKHR *>(pPipelineInfo), | |
| pExecutableCount, | |
| reinterpret_cast<VkPipelineExecutablePropertiesKHR *>(pProperties))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename PipelineExecutablePropertiesKHRAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<PipelineExecutablePropertiesKHR, PipelineExecutablePropertiesKHRAllocator>>::type | |
| Device::getPipelineExecutablePropertiesKHR(const VULKAN_HPP_NAMESPACE::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()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(executableCount <= properties.size()); | |
| if(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 VULKAN_HPP_NAMESPACE::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()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(executableCount <= properties.size()); | |
| if(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 VULKAN_HPP_NAMESPACE::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()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(statisticCount <= statistics.size()); | |
| if(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 VULKAN_HPP_NAMESPACE::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()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(statisticCount <= statistics.size()); | |
| if(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 VULKAN_HPP_NAMESPACE::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()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(internalRepresentationCount <= internalRepresentations.size()); | |
| if(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 VULKAN_HPP_NAMESPACE::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()))); | |
| } | |
| } while(result == Result::eIncomplete); | |
| if(result == VULKAN_HPP_NAMESPACE::Result::eSuccess) | |
| { | |
| VULKAN_HPP_ASSERT(internalRepresentationCount <= internalRepresentations.size()); | |
| if(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 VULKAN_HPP_NAMESPACE::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 VULKAN_HPP_NAMESPACE::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 VULKAN_HPP_NAMESPACE::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 VULKAN_HPP_NAMESPACE::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 VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV>::type | |
| Device::createIndirectCommandsLayoutNV(const VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout; | |
| VkResult 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)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::createIndirectCommandsLayoutNV"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), indirectCommandsLayout); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV, Dispatch>>::type | |
| Device::createIndirectCommandsLayoutNVUnique(const VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| 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 VULKAN_HPP_NAMESPACE::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 VULKAN_HPP_NAMESPACE::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); | |
| VkResult result = d.vkAcquireDrmDisplayEXT(m_physicalDevice, drmFd, static_cast<VkDisplayKHR>(display)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::acquireDrmDisplayEXT"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getDrmDisplayEXT(int32_t drmFd, | |
| uint32_t connectorId, | |
| VULKAN_HPP_NAMESPACE::DisplayKHR *display, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkGetDrmDisplayEXT(m_physicalDevice, drmFd, connectorId, reinterpret_cast<VkDisplayKHR *>(display))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayKHR>::type | |
| PhysicalDevice::getDrmDisplayEXT(int32_t drmFd, uint32_t connectorId, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::DisplayKHR display; | |
| VkResult result = d.vkGetDrmDisplayEXT(m_physicalDevice, drmFd, connectorId, reinterpret_cast<VkDisplayKHR *>(&display)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDrmDisplayEXT"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), display); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>>::type | |
| PhysicalDevice::getDrmDisplayEXTUnique(int32_t drmFd, uint32_t connectorId, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| 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::PrivateDataSlotCreateInfo *pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| VULKAN_HPP_NAMESPACE::PrivateDataSlot *pPrivateDataSlot, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkCreatePrivateDataSlotEXT(m_device, | |
| reinterpret_cast<const VkPrivateDataSlotCreateInfo *>(pCreateInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(pAllocator), | |
| reinterpret_cast<VkPrivateDataSlot *>(pPrivateDataSlot))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::PrivateDataSlot>::type | |
| Device::createPrivateDataSlotEXT(const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot; | |
| VkResult result = d.vkCreatePrivateDataSlotEXT( | |
| m_device, | |
| reinterpret_cast<const VkPrivateDataSlotCreateInfo *>(&createInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)), | |
| reinterpret_cast<VkPrivateDataSlot *>(&privateDataSlot)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::createPrivateDataSlotEXT"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), privateDataSlot); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PrivateDataSlot, Dispatch>>::type | |
| Device::createPrivateDataSlotEXTUnique(const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot; | |
| Result result = static_cast<Result>(d.vkCreatePrivateDataSlotEXT( | |
| m_device, | |
| reinterpret_cast<const VkPrivateDataSlotCreateInfo *>(&createInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)), | |
| reinterpret_cast<VkPrivateDataSlot *>(&privateDataSlot))); | |
| ObjectDestroy<Device, Dispatch> deleter(*this, allocator, d); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::PrivateDataSlot, 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::PrivateDataSlot privateDataSlot, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyPrivateDataSlotEXT(m_device, static_cast<VkPrivateDataSlot>(privateDataSlot), reinterpret_cast<const VkAllocationCallbacks *>(pAllocator)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroyPrivateDataSlotEXT(VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyPrivateDataSlotEXT( | |
| m_device, | |
| static_cast<VkPrivateDataSlot>(privateDataSlot), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::setPrivateDataEXT(VULKAN_HPP_NAMESPACE::ObjectType objectType, | |
| uint64_t objectHandle, | |
| VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, | |
| uint64_t data, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>( | |
| d.vkSetPrivateDataEXT(m_device, static_cast<VkObjectType>(objectType), objectHandle, static_cast<VkPrivateDataSlot>(privateDataSlot), data)); | |
| } | |
| #else | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::setPrivateDataEXT(VULKAN_HPP_NAMESPACE::ObjectType objectType, | |
| uint64_t objectHandle, | |
| VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, | |
| uint64_t data, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VkResult result = | |
| d.vkSetPrivateDataEXT(m_device, static_cast<VkObjectType>(objectType), objectHandle, static_cast<VkPrivateDataSlot>(privateDataSlot), data); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::setPrivateDataEXT"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::getPrivateDataEXT(VULKAN_HPP_NAMESPACE::ObjectType objectType, | |
| uint64_t objectHandle, | |
| VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, | |
| uint64_t *pData, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkGetPrivateDataEXT(m_device, static_cast<VkObjectType>(objectType), objectHandle, static_cast<VkPrivateDataSlot>(privateDataSlot), pData); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t Device::getPrivateDataEXT(VULKAN_HPP_NAMESPACE::ObjectType objectType, | |
| uint64_t objectHandle, | |
| VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| uint64_t data; | |
| d.vkGetPrivateDataEXT(m_device, static_cast<VkObjectType>(objectType), objectHandle, static_cast<VkPrivateDataSlot>(privateDataSlot), &data); | |
| return data; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #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 VULKAN_HPP_NAMESPACE::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::DependencyInfo *pDependencyInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdSetEvent2KHR(m_commandBuffer, static_cast<VkEvent>(event), reinterpret_cast<const VkDependencyInfo *>(pDependencyInfo)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setEvent2KHR(VULKAN_HPP_NAMESPACE::Event event, | |
| const VULKAN_HPP_NAMESPACE::DependencyInfo &dependencyInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdSetEvent2KHR(m_commandBuffer, static_cast<VkEvent>(event), reinterpret_cast<const VkDependencyInfo *>(&dependencyInfo)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::resetEvent2KHR(VULKAN_HPP_NAMESPACE::Event event, | |
| VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stageMask, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdResetEvent2KHR(m_commandBuffer, static_cast<VkEvent>(event), static_cast<VkPipelineStageFlags2>(stageMask)); | |
| } | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::waitEvents2KHR(uint32_t eventCount, | |
| const VULKAN_HPP_NAMESPACE::Event *pEvents, | |
| const VULKAN_HPP_NAMESPACE::DependencyInfo *pDependencyInfos, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdWaitEvents2KHR( | |
| m_commandBuffer, eventCount, reinterpret_cast<const VkEvent *>(pEvents), reinterpret_cast<const VkDependencyInfo *>(pDependencyInfos)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::waitEvents2KHR(ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const &events, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::DependencyInfo> const &dependencyInfos, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| # ifdef VULKAN_HPP_NO_EXCEPTIONS | |
| VULKAN_HPP_ASSERT(events.size() == dependencyInfos.size()); | |
| # else | |
| if(events.size() != dependencyInfos.size()) | |
| { | |
| throw LogicError(VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::waitEvents2KHR: events.size() != dependencyInfos.size()"); | |
| } | |
| # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ | |
| d.vkCmdWaitEvents2KHR(m_commandBuffer, | |
| events.size(), | |
| reinterpret_cast<const VkEvent *>(events.data()), | |
| reinterpret_cast<const VkDependencyInfo *>(dependencyInfos.data())); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier2KHR(const VULKAN_HPP_NAMESPACE::DependencyInfo *pDependencyInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdPipelineBarrier2KHR(m_commandBuffer, reinterpret_cast<const VkDependencyInfo *>(pDependencyInfo)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier2KHR(const VULKAN_HPP_NAMESPACE::DependencyInfo &dependencyInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdPipelineBarrier2KHR(m_commandBuffer, reinterpret_cast<const VkDependencyInfo *>(&dependencyInfo)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::writeTimestamp2KHR(VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stage, | |
| VULKAN_HPP_NAMESPACE::QueryPool queryPool, | |
| uint32_t query, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdWriteTimestamp2KHR(m_commandBuffer, static_cast<VkPipelineStageFlags2>(stage), static_cast<VkQueryPool>(queryPool), query); | |
| } | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Queue::submit2KHR(uint32_t submitCount, | |
| const VULKAN_HPP_NAMESPACE::SubmitInfo2 *pSubmits, | |
| VULKAN_HPP_NAMESPACE::Fence fence, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>( | |
| d.vkQueueSubmit2KHR(m_queue, submitCount, reinterpret_cast<const VkSubmitInfo2 *>(pSubmits), static_cast<VkFence>(fence))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| Queue::submit2KHR(ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo2> const &submits, VULKAN_HPP_NAMESPACE::Fence fence, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VkResult result = d.vkQueueSubmit2KHR(m_queue, submits.size(), reinterpret_cast<const VkSubmitInfo2 *>(submits.data()), static_cast<VkFence>(fence)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Queue::submit2KHR"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::writeBufferMarker2AMD(VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stage, | |
| VULKAN_HPP_NAMESPACE::Buffer dstBuffer, | |
| VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, | |
| uint32_t marker, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdWriteBufferMarker2AMD( | |
| m_commandBuffer, static_cast<VkPipelineStageFlags2>(stage), static_cast<VkBuffer>(dstBuffer), static_cast<VkDeviceSize>(dstOffset), marker); | |
| } | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Queue::getCheckpointData2NV(uint32_t *pCheckpointDataCount, | |
| VULKAN_HPP_NAMESPACE::CheckpointData2NV *pCheckpointData, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkGetQueueCheckpointData2NV(m_queue, pCheckpointDataCount, reinterpret_cast<VkCheckpointData2NV *>(pCheckpointData)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename CheckpointData2NVAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<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::CopyBufferInfo2 *pCopyBufferInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdCopyBuffer2KHR(m_commandBuffer, reinterpret_cast<const VkCopyBufferInfo2 *>(pCopyBufferInfo)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::copyBuffer2KHR(const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 ©BufferInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdCopyBuffer2KHR(m_commandBuffer, reinterpret_cast<const VkCopyBufferInfo2 *>(©BufferInfo)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::copyImage2KHR(const VULKAN_HPP_NAMESPACE::CopyImageInfo2 *pCopyImageInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdCopyImage2KHR(m_commandBuffer, reinterpret_cast<const VkCopyImageInfo2 *>(pCopyImageInfo)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::copyImage2KHR(const VULKAN_HPP_NAMESPACE::CopyImageInfo2 ©ImageInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdCopyImage2KHR(m_commandBuffer, reinterpret_cast<const VkCopyImageInfo2 *>(©ImageInfo)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage2KHR(const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 *pCopyBufferToImageInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdCopyBufferToImage2KHR(m_commandBuffer, reinterpret_cast<const VkCopyBufferToImageInfo2 *>(pCopyBufferToImageInfo)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage2KHR(const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 ©BufferToImageInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdCopyBufferToImage2KHR(m_commandBuffer, reinterpret_cast<const VkCopyBufferToImageInfo2 *>(©BufferToImageInfo)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer2KHR(const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 *pCopyImageToBufferInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdCopyImageToBuffer2KHR(m_commandBuffer, reinterpret_cast<const VkCopyImageToBufferInfo2 *>(pCopyImageToBufferInfo)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer2KHR(const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 ©ImageToBufferInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdCopyImageToBuffer2KHR(m_commandBuffer, reinterpret_cast<const VkCopyImageToBufferInfo2 *>(©ImageToBufferInfo)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::blitImage2KHR(const VULKAN_HPP_NAMESPACE::BlitImageInfo2 *pBlitImageInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdBlitImage2KHR(m_commandBuffer, reinterpret_cast<const VkBlitImageInfo2 *>(pBlitImageInfo)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::blitImage2KHR(const VULKAN_HPP_NAMESPACE::BlitImageInfo2 &blitImageInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdBlitImage2KHR(m_commandBuffer, reinterpret_cast<const VkBlitImageInfo2 *>(&blitImageInfo)); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::resolveImage2KHR(const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 *pResolveImageInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdResolveImage2KHR(m_commandBuffer, reinterpret_cast<const VkResolveImageInfo2 *>(pResolveImageInfo)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::resolveImage2KHR(const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 &resolveImageInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdResolveImage2KHR(m_commandBuffer, reinterpret_cast<const VkResolveImageInfo2 *>(&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); | |
| VkResult result = d.vkAcquireWinrtDisplayNV(m_physicalDevice, static_cast<VkDisplayKHR>(display)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::acquireWinrtDisplayNV"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result)); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getWinrtDisplayNV(uint32_t deviceRelativeId, | |
| VULKAN_HPP_NAMESPACE::DisplayKHR *pDisplay, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkGetWinrtDisplayNV(m_physicalDevice, deviceRelativeId, reinterpret_cast<VkDisplayKHR *>(pDisplay))); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayKHR>::type | |
| PhysicalDevice::getWinrtDisplayNV(uint32_t deviceRelativeId, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::DisplayKHR display; | |
| VkResult result = d.vkGetWinrtDisplayNV(m_physicalDevice, deviceRelativeId, reinterpret_cast<VkDisplayKHR *>(&display)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getWinrtDisplayNV"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), display); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>>::type | |
| PhysicalDevice::getWinrtDisplayNVUnique(uint32_t deviceRelativeId, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| 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 VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type | |
| Instance::createDirectFBSurfaceEXT(const VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface; | |
| VkResult 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)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Instance::createDirectFBSurfaceEXT"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), surface); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type | |
| Instance::createDirectFBSurfaceEXTUnique(const VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| 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 VULKAN_HPP_NAMESPACE::Bool32 | |
| PhysicalDevice::getDirectFBPresentationSupportEXT(uint32_t queueFamilyIndex, IDirectFB &dfb, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VkBool32 result = d.vkGetPhysicalDeviceDirectFBPresentationSupportEXT(m_physicalDevice, queueFamilyIndex, &dfb); | |
| return static_cast<VULKAN_HPP_NAMESPACE::Bool32>(result); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ | |
| //=== VK_KHR_ray_tracing_pipeline === | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::traceRaysKHR(const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR *pRaygenShaderBindingTable, | |
| const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR *pMissShaderBindingTable, | |
| const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR *pHitShaderBindingTable, | |
| const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR *pCallableShaderBindingTable, | |
| uint32_t width, | |
| uint32_t height, | |
| uint32_t depth, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdTraceRaysKHR(m_commandBuffer, | |
| reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>(pRaygenShaderBindingTable), | |
| reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>(pMissShaderBindingTable), | |
| reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>(pHitShaderBindingTable), | |
| reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>(pCallableShaderBindingTable), | |
| width, | |
| height, | |
| depth); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::traceRaysKHR(const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR &raygenShaderBindingTable, | |
| const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR &missShaderBindingTable, | |
| const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR &hitShaderBindingTable, | |
| const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR &callableShaderBindingTable, | |
| uint32_t width, | |
| uint32_t height, | |
| uint32_t depth, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdTraceRaysKHR(m_commandBuffer, | |
| reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>(&raygenShaderBindingTable), | |
| reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>(&missShaderBindingTable), | |
| reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>(&hitShaderBindingTable), | |
| reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>(&callableShaderBindingTable), | |
| width, | |
| height, | |
| depth); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::createRayTracingPipelinesKHR(VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, | |
| VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| uint32_t createInfoCount, | |
| const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR *pCreateInfos, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| VULKAN_HPP_NAMESPACE::Pipeline *pPipelines, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkCreateRayTracingPipelinesKHR(m_device, | |
| static_cast<VkDeferredOperationKHR>(deferredOperation), | |
| static_cast<VkPipelineCache>(pipelineCache), | |
| createInfoCount, | |
| reinterpret_cast<const VkRayTracingPipelineCreateInfoKHR *>(pCreateInfos), | |
| reinterpret_cast<const VkAllocationCallbacks *>(pAllocator), | |
| reinterpret_cast<VkPipeline *>(pPipelines))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename PipelineAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>> | |
| Device::createRayTracingPipelinesKHR(VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, | |
| VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const &createInfos, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator> pipelines(createInfos.size()); | |
| VkResult 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())); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesKHR", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, | |
| VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR, | |
| VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR, | |
| VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT }); | |
| return ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), pipelines); | |
| } | |
| template<typename PipelineAllocator, | |
| typename Dispatch, | |
| typename B, | |
| typename std::enable_if<std::is_same<typename B::value_type, Pipeline>::value, int>::type> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>> | |
| Device::createRayTracingPipelinesKHR(VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, | |
| VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const &createInfos, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| PipelineAllocator &pipelineAllocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator> pipelines(createInfos.size(), pipelineAllocator); | |
| VkResult 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())); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesKHR", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, | |
| VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR, | |
| VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR, | |
| VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT }); | |
| return ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), pipelines); | |
| } | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<VULKAN_HPP_NAMESPACE::Pipeline> | |
| Device::createRayTracingPipelineKHR(VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, | |
| VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, | |
| const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::Pipeline pipeline; | |
| VkResult 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)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelineKHR", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, | |
| VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR, | |
| VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR, | |
| VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT }); | |
| return ResultValue<VULKAN_HPP_NAMESPACE::Pipeline>(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), pipeline); | |
| } | |
| # 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 VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator> uniquePipelines; | |
| std::vector<Pipeline> pipelines(createInfos.size()); | |
| Result result = static_cast<Result>(d.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 VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| PipelineAllocator &pipelineAllocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator> uniquePipelines(pipelineAllocator); | |
| std::vector<Pipeline> pipelines(createInfos.size()); | |
| Result result = static_cast<Result>(d.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 VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| Pipeline pipeline; | |
| Result result = static_cast<Result>(d.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 DataType, typename DataTypeAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type Device::getRayTracingShaderGroupHandlesKHR( | |
| VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_ASSERT(dataSize % sizeof(DataType) == 0); | |
| std::vector<DataType, DataTypeAllocator> data(dataSize / sizeof(DataType)); | |
| Result result = static_cast<Result>(d.vkGetRayTracingShaderGroupHandlesKHR( | |
| m_device, static_cast<VkPipeline>(pipeline), firstGroup, groupCount, data.size() * sizeof(DataType), reinterpret_cast<void *>(data.data()))); | |
| return createResultValue(result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandlesKHR"); | |
| } | |
| template<typename DataType, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<DataType>::type | |
| Device::getRayTracingShaderGroupHandleKHR(VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| DataType data; | |
| VkResult result = d.vkGetRayTracingShaderGroupHandlesKHR( | |
| m_device, static_cast<VkPipeline>(pipeline), firstGroup, groupCount, sizeof(DataType), reinterpret_cast<void *>(&data)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandleKHR"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), data); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getRayTracingCaptureReplayShaderGroupHandlesKHR(VULKAN_HPP_NAMESPACE::Pipeline pipeline, | |
| uint32_t firstGroup, | |
| uint32_t groupCount, | |
| size_t dataSize, | |
| void *pData, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>( | |
| d.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(m_device, static_cast<VkPipeline>(pipeline), firstGroup, groupCount, dataSize, pData)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename DataType, typename DataTypeAllocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type | |
| Device::getRayTracingCaptureReplayShaderGroupHandlesKHR( | |
| VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_ASSERT(dataSize % sizeof(DataType) == 0); | |
| std::vector<DataType, DataTypeAllocator> data(dataSize / sizeof(DataType)); | |
| Result result = static_cast<Result>(d.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( | |
| m_device, static_cast<VkPipeline>(pipeline), firstGroup, groupCount, data.size() * sizeof(DataType), reinterpret_cast<void *>(data.data()))); | |
| return createResultValue(result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingCaptureReplayShaderGroupHandlesKHR"); | |
| } | |
| template<typename DataType, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<DataType>::type Device::getRayTracingCaptureReplayShaderGroupHandleKHR( | |
| VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| DataType data; | |
| VkResult result = d.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( | |
| m_device, static_cast<VkPipeline>(pipeline), firstGroup, groupCount, sizeof(DataType), reinterpret_cast<void *>(&data)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingCaptureReplayShaderGroupHandleKHR"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), data); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::traceRaysIndirectKHR(const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR *pRaygenShaderBindingTable, | |
| const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR *pMissShaderBindingTable, | |
| const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR *pHitShaderBindingTable, | |
| const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR *pCallableShaderBindingTable, | |
| VULKAN_HPP_NAMESPACE::DeviceAddress indirectDeviceAddress, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdTraceRaysIndirectKHR(m_commandBuffer, | |
| reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>(pRaygenShaderBindingTable), | |
| reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>(pMissShaderBindingTable), | |
| reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>(pHitShaderBindingTable), | |
| reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>(pCallableShaderBindingTable), | |
| static_cast<VkDeviceAddress>(indirectDeviceAddress)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::traceRaysIndirectKHR(const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR &raygenShaderBindingTable, | |
| const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR &missShaderBindingTable, | |
| const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR &hitShaderBindingTable, | |
| const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR &callableShaderBindingTable, | |
| VULKAN_HPP_NAMESPACE::DeviceAddress indirectDeviceAddress, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| 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 VULKAN_HPP_INLINE typename ResultValueType<zx_handle_t>::type | |
| Device::getMemoryZirconHandleFUCHSIA(const VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA &getZirconHandleInfo, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| zx_handle_t zirconHandle; | |
| VkResult result = | |
| d.vkGetMemoryZirconHandleFUCHSIA(m_device, reinterpret_cast<const VkMemoryGetZirconHandleInfoFUCHSIA *>(&getZirconHandleInfo), &zirconHandle); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryZirconHandleFUCHSIA"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), zirconHandle); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::getMemoryZirconHandlePropertiesFUCHSIA(VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, | |
| zx_handle_t zirconHandle, | |
| VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA *pMemoryZirconHandleProperties, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>( | |
| d.vkGetMemoryZirconHandlePropertiesFUCHSIA(m_device, | |
| static_cast<VkExternalMemoryHandleTypeFlagBits>(handleType), | |
| zirconHandle, | |
| reinterpret_cast<VkMemoryZirconHandlePropertiesFUCHSIA *>(pMemoryZirconHandleProperties))); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA>::type | |
| Device::getMemoryZirconHandlePropertiesFUCHSIA(VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, | |
| zx_handle_t zirconHandle, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA memoryZirconHandleProperties; | |
| VkResult result = d.vkGetMemoryZirconHandlePropertiesFUCHSIA(m_device, | |
| static_cast<VkExternalMemoryHandleTypeFlagBits>(handleType), | |
| zirconHandle, | |
| reinterpret_cast<VkMemoryZirconHandlePropertiesFUCHSIA *>(&memoryZirconHandleProperties)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryZirconHandlePropertiesFUCHSIA"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), memoryZirconHandleProperties); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #endif /*VK_USE_PLATFORM_FUCHSIA*/ | |
| #if defined(VK_USE_PLATFORM_FUCHSIA) | |
| //=== VK_FUCHSIA_external_semaphore === | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::importSemaphoreZirconHandleFUCHSIA( | |
| const VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA *pImportSemaphoreZirconHandleInfo, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkImportSemaphoreZirconHandleFUCHSIA( | |
| m_device, reinterpret_cast<const VkImportSemaphoreZirconHandleInfoFUCHSIA *>(pImportSemaphoreZirconHandleInfo))); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| Device::importSemaphoreZirconHandleFUCHSIA(const VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA &importSemaphoreZirconHandleInfo, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VkResult result = d.vkImportSemaphoreZirconHandleFUCHSIA( | |
| m_device, reinterpret_cast<const VkImportSemaphoreZirconHandleInfoFUCHSIA *>(&importSemaphoreZirconHandleInfo)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::importSemaphoreZirconHandleFUCHSIA"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result)); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::getSemaphoreZirconHandleFUCHSIA(const VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA *pGetZirconHandleInfo, | |
| zx_handle_t *pZirconHandle, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>( | |
| d.vkGetSemaphoreZirconHandleFUCHSIA(m_device, reinterpret_cast<const VkSemaphoreGetZirconHandleInfoFUCHSIA *>(pGetZirconHandleInfo), pZirconHandle)); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<zx_handle_t>::type | |
| Device::getSemaphoreZirconHandleFUCHSIA(const VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA &getZirconHandleInfo, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| zx_handle_t zirconHandle; | |
| VkResult result = | |
| d.vkGetSemaphoreZirconHandleFUCHSIA(m_device, reinterpret_cast<const VkSemaphoreGetZirconHandleInfoFUCHSIA *>(&getZirconHandleInfo), &zirconHandle); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreZirconHandleFUCHSIA"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), zirconHandle); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #endif /*VK_USE_PLATFORM_FUCHSIA*/ | |
| #if defined(VK_USE_PLATFORM_FUCHSIA) | |
| //=== VK_FUCHSIA_buffer_collection === | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::createBufferCollectionFUCHSIA(const VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA *pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA *pCollection, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkCreateBufferCollectionFUCHSIA(m_device, | |
| reinterpret_cast<const VkBufferCollectionCreateInfoFUCHSIA *>(pCreateInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(pAllocator), | |
| reinterpret_cast<VkBufferCollectionFUCHSIA *>(pCollection))); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA>::type | |
| Device::createBufferCollectionFUCHSIA(const VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection; | |
| VkResult result = d.vkCreateBufferCollectionFUCHSIA( | |
| m_device, | |
| reinterpret_cast<const VkBufferCollectionCreateInfoFUCHSIA *>(&createInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)), | |
| reinterpret_cast<VkBufferCollectionFUCHSIA *>(&collection)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::createBufferCollectionFUCHSIA"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), collection); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA, Dispatch>>::type | |
| Device::createBufferCollectionFUCHSIAUnique(const VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection; | |
| Result result = static_cast<Result>(d.vkCreateBufferCollectionFUCHSIA( | |
| m_device, | |
| reinterpret_cast<const VkBufferCollectionCreateInfoFUCHSIA *>(&createInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator)), | |
| reinterpret_cast<VkBufferCollectionFUCHSIA *>(&collection))); | |
| ObjectDestroy<Device, Dispatch> deleter(*this, allocator, d); | |
| return createResultValue<VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA, Dispatch>( | |
| result, collection, VULKAN_HPP_NAMESPACE_STRING "::Device::createBufferCollectionFUCHSIAUnique", deleter); | |
| } | |
| # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::setBufferCollectionImageConstraintsFUCHSIA(VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection, | |
| const VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA *pImageConstraintsInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkSetBufferCollectionImageConstraintsFUCHSIA( | |
| m_device, static_cast<VkBufferCollectionFUCHSIA>(collection), reinterpret_cast<const VkImageConstraintsInfoFUCHSIA *>(pImageConstraintsInfo))); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| Device::setBufferCollectionImageConstraintsFUCHSIA(VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection, | |
| const VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA &imageConstraintsInfo, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VkResult result = d.vkSetBufferCollectionImageConstraintsFUCHSIA( | |
| m_device, static_cast<VkBufferCollectionFUCHSIA>(collection), reinterpret_cast<const VkImageConstraintsInfoFUCHSIA *>(&imageConstraintsInfo)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::setBufferCollectionImageConstraintsFUCHSIA"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result)); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::setBufferCollectionBufferConstraintsFUCHSIA(VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection, | |
| const VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA *pBufferConstraintsInfo, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkSetBufferCollectionBufferConstraintsFUCHSIA( | |
| m_device, static_cast<VkBufferCollectionFUCHSIA>(collection), reinterpret_cast<const VkBufferConstraintsInfoFUCHSIA *>(pBufferConstraintsInfo))); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type | |
| Device::setBufferCollectionBufferConstraintsFUCHSIA(VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection, | |
| const VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA &bufferConstraintsInfo, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VkResult result = d.vkSetBufferCollectionBufferConstraintsFUCHSIA( | |
| m_device, static_cast<VkBufferCollectionFUCHSIA>(collection), reinterpret_cast<const VkBufferConstraintsInfoFUCHSIA *>(&bufferConstraintsInfo)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::setBufferCollectionBufferConstraintsFUCHSIA"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result)); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroyBufferCollectionFUCHSIA(VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyBufferCollectionFUCHSIA( | |
| m_device, static_cast<VkBufferCollectionFUCHSIA>(collection), reinterpret_cast<const VkAllocationCallbacks *>(pAllocator)); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroyBufferCollectionFUCHSIA(VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyBufferCollectionFUCHSIA( | |
| m_device, | |
| static_cast<VkBufferCollectionFUCHSIA>(collection), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy(VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyBufferCollectionFUCHSIA( | |
| m_device, static_cast<VkBufferCollectionFUCHSIA>(collection), reinterpret_cast<const VkAllocationCallbacks *>(pAllocator)); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::destroy(VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkDestroyBufferCollectionFUCHSIA( | |
| m_device, | |
| static_cast<VkBufferCollectionFUCHSIA>(collection), | |
| reinterpret_cast<const VkAllocationCallbacks *>(static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(allocator))); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::getBufferCollectionPropertiesFUCHSIA(VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection, | |
| VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA *pProperties, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkGetBufferCollectionPropertiesFUCHSIA( | |
| m_device, static_cast<VkBufferCollectionFUCHSIA>(collection), reinterpret_cast<VkBufferCollectionPropertiesFUCHSIA *>(pProperties))); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA>::type | |
| Device::getBufferCollectionPropertiesFUCHSIA(VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA properties; | |
| VkResult result = d.vkGetBufferCollectionPropertiesFUCHSIA( | |
| m_device, static_cast<VkBufferCollectionFUCHSIA>(collection), reinterpret_cast<VkBufferCollectionPropertiesFUCHSIA *>(&properties)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::getBufferCollectionPropertiesFUCHSIA"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), properties); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #endif /*VK_USE_PLATFORM_FUCHSIA*/ | |
| //=== VK_HUAWEI_subpass_shading === | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSubpassShadingMaxWorkgroupSizeHUAWEI(VULKAN_HPP_NAMESPACE::RenderPass renderpass, | |
| VULKAN_HPP_NAMESPACE::Extent2D *pMaxWorkgroupSize, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( | |
| m_device, static_cast<VkRenderPass>(renderpass), reinterpret_cast<VkExtent2D *>(pMaxWorkgroupSize))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE 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; | |
| VkResult result = d.vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( | |
| m_device, static_cast<VkRenderPass>(renderpass), reinterpret_cast<VkExtent2D *>(&maxWorkgroupSize)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), | |
| VULKAN_HPP_NAMESPACE_STRING "::Device::getSubpassShadingMaxWorkgroupSizeHUAWEI", | |
| { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eIncomplete }); | |
| return ResultValue<VULKAN_HPP_NAMESPACE::Extent2D>(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), maxWorkgroupSize); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::subpassShadingHUAWEI(Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdSubpassShadingHUAWEI(m_commandBuffer); | |
| } | |
| //=== VK_HUAWEI_invocation_mask === | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::bindInvocationMaskHUAWEI(VULKAN_HPP_NAMESPACE::ImageView imageView, | |
| VULKAN_HPP_NAMESPACE::ImageLayout imageLayout, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdBindInvocationMaskHUAWEI(m_commandBuffer, static_cast<VkImageView>(imageView), static_cast<VkImageLayout>(imageLayout)); | |
| } | |
| //=== VK_NV_external_memory_rdma === | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result | |
| Device::getMemoryRemoteAddressNV(const VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV *pMemoryGetRemoteAddressInfo, | |
| VULKAN_HPP_NAMESPACE::RemoteAddressNV *pAddress, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkGetMemoryRemoteAddressNV( | |
| m_device, reinterpret_cast<const VkMemoryGetRemoteAddressInfoNV *>(pMemoryGetRemoteAddressInfo), reinterpret_cast<VkRemoteAddressNV *>(pAddress))); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::RemoteAddressNV>::type | |
| Device::getMemoryRemoteAddressNV(const VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV &memoryGetRemoteAddressInfo, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::RemoteAddressNV address; | |
| VkResult result = d.vkGetMemoryRemoteAddressNV( | |
| m_device, reinterpret_cast<const VkMemoryGetRemoteAddressInfoNV *>(&memoryGetRemoteAddressInfo), reinterpret_cast<VkRemoteAddressNV *>(&address)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryRemoteAddressNV"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), address); | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_EXT_extended_dynamic_state2 === | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setPatchControlPointsEXT(uint32_t patchControlPoints, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdSetPatchControlPointsEXT(m_commandBuffer, patchControlPoints); | |
| } | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setRasterizerDiscardEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdSetRasterizerDiscardEnableEXT(m_commandBuffer, static_cast<VkBool32>(rasterizerDiscardEnable)); | |
| } | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setDepthBiasEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdSetDepthBiasEnableEXT(m_commandBuffer, static_cast<VkBool32>(depthBiasEnable)); | |
| } | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setLogicOpEXT(VULKAN_HPP_NAMESPACE::LogicOp logicOp, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdSetLogicOpEXT(m_commandBuffer, static_cast<VkLogicOp>(logicOp)); | |
| } | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setPrimitiveRestartEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdSetPrimitiveRestartEnableEXT(m_commandBuffer, static_cast<VkBool32>(primitiveRestartEnable)); | |
| } | |
| #if defined(VK_USE_PLATFORM_SCREEN_QNX) | |
| //=== VK_QNX_screen_surface === | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createScreenSurfaceQNX(const VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX *pCreateInfo, | |
| const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, | |
| VULKAN_HPP_NAMESPACE::SurfaceKHR *pSurface, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| return static_cast<Result>(d.vkCreateScreenSurfaceQNX(m_instance, | |
| reinterpret_cast<const VkScreenSurfaceCreateInfoQNX *>(pCreateInfo), | |
| reinterpret_cast<const VkAllocationCallbacks *>(pAllocator), | |
| reinterpret_cast<VkSurfaceKHR *>(pSurface))); | |
| } | |
| # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type | |
| Instance::createScreenSurfaceQNX(const VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::SurfaceKHR surface; | |
| VkResult 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)); | |
| resultCheck(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), VULKAN_HPP_NAMESPACE_STRING "::Instance::createScreenSurfaceQNX"); | |
| return createResultValueType(static_cast<VULKAN_HPP_NAMESPACE::Result>(result), surface); | |
| } | |
| # ifndef VULKAN_HPP_NO_SMART_HANDLE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type | |
| Instance::createScreenSurfaceQNXUnique(const VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX &createInfo, | |
| Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, | |
| Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| 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 VULKAN_HPP_NAMESPACE::Bool32 | |
| PhysicalDevice::getScreenPresentationSupportQNX(uint32_t queueFamilyIndex, struct _screen_window &window, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VkBool32 result = d.vkGetPhysicalDeviceScreenPresentationSupportQNX(m_physicalDevice, queueFamilyIndex, &window); | |
| return static_cast<VULKAN_HPP_NAMESPACE::Bool32>(result); | |
| } | |
| # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| #endif /*VK_USE_PLATFORM_SCREEN_QNX*/ | |
| //=== VK_EXT_color_write_enable === | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setColorWriteEnableEXT(uint32_t attachmentCount, | |
| const VULKAN_HPP_NAMESPACE::Bool32 *pColorWriteEnables, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkCmdSetColorWriteEnableEXT(m_commandBuffer, attachmentCount, reinterpret_cast<const VkBool32 *>(pColorWriteEnables)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void CommandBuffer::setColorWriteEnableEXT(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*/ | |
| //=== VK_EXT_pageable_device_local_memory === | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::setMemoryPriorityEXT(VULKAN_HPP_NAMESPACE::DeviceMemory memory, float priority, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkSetDeviceMemoryPriorityEXT(m_device, static_cast<VkDeviceMemory>(memory), priority); | |
| } | |
| //=== VK_KHR_maintenance4 === | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::getBufferMemoryRequirementsKHR(const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements *pInfo, | |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 *pMemoryRequirements, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkGetDeviceBufferMemoryRequirementsKHR( | |
| m_device, reinterpret_cast<const VkDeviceBufferMemoryRequirements *>(pInfo), reinterpret_cast<VkMemoryRequirements2 *>(pMemoryRequirements)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2 | |
| Device::getBufferMemoryRequirementsKHR(const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements &info, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements; | |
| d.vkGetDeviceBufferMemoryRequirementsKHR( | |
| m_device, reinterpret_cast<const VkDeviceBufferMemoryRequirements *>(&info), reinterpret_cast<VkMemoryRequirements2 *>(&memoryRequirements)); | |
| return memoryRequirements; | |
| } | |
| template<typename X, typename Y, typename... Z, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> | |
| Device::getBufferMemoryRequirementsKHR(const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements &info, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| StructureChain<X, Y, Z...> structureChain; | |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 &memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>(); | |
| d.vkGetDeviceBufferMemoryRequirementsKHR( | |
| m_device, reinterpret_cast<const VkDeviceBufferMemoryRequirements *>(&info), reinterpret_cast<VkMemoryRequirements2 *>(&memoryRequirements)); | |
| return structureChain; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::getImageMemoryRequirementsKHR(const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements *pInfo, | |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 *pMemoryRequirements, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkGetDeviceImageMemoryRequirementsKHR( | |
| m_device, reinterpret_cast<const VkDeviceImageMemoryRequirements *>(pInfo), reinterpret_cast<VkMemoryRequirements2 *>(pMemoryRequirements)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2 | |
| Device::getImageMemoryRequirementsKHR(const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements &info, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements; | |
| d.vkGetDeviceImageMemoryRequirementsKHR( | |
| m_device, reinterpret_cast<const VkDeviceImageMemoryRequirements *>(&info), reinterpret_cast<VkMemoryRequirements2 *>(&memoryRequirements)); | |
| return memoryRequirements; | |
| } | |
| template<typename X, typename Y, typename... Z, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> | |
| Device::getImageMemoryRequirementsKHR(const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements &info, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| StructureChain<X, Y, Z...> structureChain; | |
| VULKAN_HPP_NAMESPACE::MemoryRequirements2 &memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>(); | |
| d.vkGetDeviceImageMemoryRequirementsKHR( | |
| m_device, reinterpret_cast<const VkDeviceImageMemoryRequirements *>(&info), reinterpret_cast<VkMemoryRequirements2 *>(&memoryRequirements)); | |
| return structureChain; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirementsKHR(const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements *pInfo, | |
| uint32_t *pSparseMemoryRequirementCount, | |
| VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 *pSparseMemoryRequirements, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkGetDeviceImageSparseMemoryRequirementsKHR(m_device, | |
| reinterpret_cast<const VkDeviceImageMemoryRequirements *>(pInfo), | |
| pSparseMemoryRequirementCount, | |
| reinterpret_cast<VkSparseImageMemoryRequirements2 *>(pSparseMemoryRequirements)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename SparseImageMemoryRequirements2Allocator, typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> | |
| Device::getImageSparseMemoryRequirementsKHR(const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements &info, Dispatch const &d) const | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> sparseMemoryRequirements; | |
| uint32_t sparseMemoryRequirementCount; | |
| d.vkGetDeviceImageSparseMemoryRequirementsKHR( | |
| m_device, reinterpret_cast<const VkDeviceImageMemoryRequirements *>(&info), &sparseMemoryRequirementCount, nullptr); | |
| sparseMemoryRequirements.resize(sparseMemoryRequirementCount); | |
| d.vkGetDeviceImageSparseMemoryRequirementsKHR(m_device, | |
| reinterpret_cast<const VkDeviceImageMemoryRequirements *>(&info), | |
| &sparseMemoryRequirementCount, | |
| reinterpret_cast<VkSparseImageMemoryRequirements2 *>(sparseMemoryRequirements.data())); | |
| VULKAN_HPP_ASSERT(sparseMemoryRequirementCount <= sparseMemoryRequirements.size()); | |
| 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::getImageSparseMemoryRequirementsKHR(const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements &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.vkGetDeviceImageSparseMemoryRequirementsKHR( | |
| m_device, reinterpret_cast<const VkDeviceImageMemoryRequirements *>(&info), &sparseMemoryRequirementCount, nullptr); | |
| sparseMemoryRequirements.resize(sparseMemoryRequirementCount); | |
| d.vkGetDeviceImageSparseMemoryRequirementsKHR(m_device, | |
| reinterpret_cast<const VkDeviceImageMemoryRequirements *>(&info), | |
| &sparseMemoryRequirementCount, | |
| reinterpret_cast<VkSparseImageMemoryRequirements2 *>(sparseMemoryRequirements.data())); | |
| VULKAN_HPP_ASSERT(sparseMemoryRequirementCount <= sparseMemoryRequirements.size()); | |
| return sparseMemoryRequirements; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| //=== VK_VALVE_descriptor_set_host_mapping === | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void Device::getDescriptorSetLayoutHostMappingInfoVALVE(const VULKAN_HPP_NAMESPACE::DescriptorSetBindingReferenceVALVE *pBindingReference, | |
| VULKAN_HPP_NAMESPACE::DescriptorSetLayoutHostMappingInfoVALVE *pHostMapping, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkGetDescriptorSetLayoutHostMappingInfoVALVE(m_device, | |
| reinterpret_cast<const VkDescriptorSetBindingReferenceVALVE *>(pBindingReference), | |
| reinterpret_cast<VkDescriptorSetLayoutHostMappingInfoVALVE *>(pHostMapping)); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DescriptorSetLayoutHostMappingInfoVALVE | |
| Device::getDescriptorSetLayoutHostMappingInfoVALVE(const VULKAN_HPP_NAMESPACE::DescriptorSetBindingReferenceVALVE &bindingReference, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| VULKAN_HPP_NAMESPACE::DescriptorSetLayoutHostMappingInfoVALVE hostMapping; | |
| d.vkGetDescriptorSetLayoutHostMappingInfoVALVE(m_device, | |
| reinterpret_cast<const VkDescriptorSetBindingReferenceVALVE *>(&bindingReference), | |
| reinterpret_cast<VkDescriptorSetLayoutHostMappingInfoVALVE *>(&hostMapping)); | |
| return hostMapping; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| template<typename Dispatch> | |
| VULKAN_HPP_INLINE void | |
| Device::getDescriptorSetHostMappingVALVE(VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet, void **ppData, Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| d.vkGetDescriptorSetHostMappingVALVE(m_device, static_cast<VkDescriptorSet>(descriptorSet), ppData); | |
| } | |
| #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE | |
| template<typename Dispatch> | |
| VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE void *Device::getDescriptorSetHostMappingVALVE(VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet, | |
| Dispatch const &d) const VULKAN_HPP_NOEXCEPT | |
| { | |
| VULKAN_HPP_ASSERT(d.getVkHeaderVersion() == VK_HEADER_VERSION); | |
| void *pData; | |
| d.vkGetDescriptorSetHostMappingVALVE(m_device, static_cast<VkDescriptorSet>(descriptorSet), &pData); | |
| return pData; | |
| } | |
| #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ | |
| } // namespace VULKAN_HPP_NAMESPACE | |
| #endif |