Mercurial > games > semicongine

comparison fuhtark_test/Vulkan-Headers-1.4.334/include/vulkan/vulkan_funcs.hpp @ 1501:f40d9d814c08 default tip main

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
did: correct vulkan-api generator
author sam <sam@basx.dev>
date Wed, 26 Nov 2025 23:34:29 +0700
parents
children
comparison
equal deleted inserted replaced
1500:91c8c3b7cbf0 1501:f40d9d814c08
1 // Copyright 2015-2025 The Khronos Group Inc.
2 //
3 // SPDX-License-Identifier: Apache-2.0 OR MIT
4 //
5
6 // This header is generated from the Khronos Vulkan XML API Registry.
7
8 #ifndef VULKAN_FUNCS_HPP
9 #define VULKAN_FUNCS_HPP
10
11 // include-what-you-use: make sure, vulkan.hpp is used by code-completers
12 // IWYU pragma: private, include "vulkan/vulkan.hpp"
13
14 namespace VULKAN_HPP_NAMESPACE
15 {
16
17 //===========================
18 //=== COMMAND Definitions ===
19 //===========================
20
21 //=== VK_VERSION_1_0 ===
22
23 // wrapper function for command vkCreateInstance, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateInstance.html
24 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
25 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result createInstance( const InstanceCreateInfo * pCreateInfo,
26 const AllocationCallbacks * pAllocator,
27 Instance * pInstance,
28 Dispatch const & d ) VULKAN_HPP_NOEXCEPT
29 {
30 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
31 return static_cast<Result>( d.vkCreateInstance( reinterpret_cast<const VkInstanceCreateInfo *>( pCreateInfo ),
32 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
33 reinterpret_cast<VkInstance *>( pInstance ) ) );
34 }
35
36 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
37 // wrapper function for command vkCreateInstance, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateInstance.html
38 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
39 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<Instance>::type
40 createInstance( const InstanceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d )
41 {
42 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
43 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
44 VULKAN_HPP_ASSERT( d.vkCreateInstance && "Function <vkCreateInstance> requires <VK_VERSION_1_0>" );
45 # endif
46
47 Instance instance;
48 Result result = static_cast<Result>( d.vkCreateInstance( reinterpret_cast<const VkInstanceCreateInfo *>( &createInfo ),
49 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
50 reinterpret_cast<VkInstance *>( &instance ) ) );
51 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::createInstance" );
52
53 return detail::createResultValueType( result, std::move( instance ) );
54 }
55
56 # ifndef VULKAN_HPP_NO_SMART_HANDLE
57 // wrapper function for command vkCreateInstance, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateInstance.html
58 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
59 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Instance, Dispatch>>::type
60 createInstanceUnique( const InstanceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d )
61 {
62 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
63 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
64 VULKAN_HPP_ASSERT( d.vkCreateInstance && "Function <vkCreateInstance> requires <VK_VERSION_1_0>" );
65 # endif
66
67 Instance instance;
68 Result result = static_cast<Result>( d.vkCreateInstance( reinterpret_cast<const VkInstanceCreateInfo *>( &createInfo ),
69 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
70 reinterpret_cast<VkInstance *>( &instance ) ) );
71 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::createInstanceUnique" );
72
73 return detail::createResultValueType( result,
74 UniqueHandle<Instance, Dispatch>( instance, detail::ObjectDestroy<detail::NoParent, Dispatch>( allocator, d ) ) );
75 }
76 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
77 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
78
79 // wrapper function for command vkDestroyInstance, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyInstance.html
80 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
81 VULKAN_HPP_INLINE void Instance::destroy( const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
82 {
83 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
84 d.vkDestroyInstance( static_cast<VkInstance>( m_instance ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
85 }
86
87 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
88 // wrapper function for command vkDestroyInstance, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyInstance.html
89 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
90 VULKAN_HPP_INLINE void Instance::destroy( Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
91 {
92 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
93 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
94 VULKAN_HPP_ASSERT( d.vkDestroyInstance && "Function <vkDestroyInstance> requires <VK_VERSION_1_0>" );
95 # endif
96
97 d.vkDestroyInstance( m_instance, reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
98 }
99 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
100
101 // wrapper function for command vkEnumeratePhysicalDevices, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDevices.html
102 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
103 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::enumeratePhysicalDevices( uint32_t * pPhysicalDeviceCount,
104 PhysicalDevice * pPhysicalDevices,
105 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
106 {
107 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
108 return static_cast<Result>(
109 d.vkEnumeratePhysicalDevices( static_cast<VkInstance>( m_instance ), pPhysicalDeviceCount, reinterpret_cast<VkPhysicalDevice *>( pPhysicalDevices ) ) );
110 }
111
112 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
113 // wrapper function for command vkEnumeratePhysicalDevices, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDevices.html
114 template <typename PhysicalDeviceAllocator,
115 typename Dispatch,
116 typename std::enable_if<std::is_same<typename PhysicalDeviceAllocator::value_type, PhysicalDevice>::value, int>::type,
117 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
118 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<PhysicalDevice, PhysicalDeviceAllocator>>::type
119 Instance::enumeratePhysicalDevices( Dispatch const & d ) const
120 {
121 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
122 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
123 VULKAN_HPP_ASSERT( d.vkEnumeratePhysicalDevices && "Function <vkEnumeratePhysicalDevices> requires <VK_VERSION_1_0>" );
124 # endif
125
126 std::vector<PhysicalDevice, PhysicalDeviceAllocator> physicalDevices;
127 uint32_t physicalDeviceCount;
128 Result result;
129 do
130 {
131 result = static_cast<Result>( d.vkEnumeratePhysicalDevices( m_instance, &physicalDeviceCount, nullptr ) );
132 if ( ( result == Result::eSuccess ) && physicalDeviceCount )
133 {
134 physicalDevices.resize( physicalDeviceCount );
135 result = static_cast<Result>(
136 d.vkEnumeratePhysicalDevices( m_instance, &physicalDeviceCount, reinterpret_cast<VkPhysicalDevice *>( physicalDevices.data() ) ) );
137 }
138 } while ( result == Result::eIncomplete );
139 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::enumeratePhysicalDevices" );
140 VULKAN_HPP_ASSERT( physicalDeviceCount <= physicalDevices.size() );
141 if ( physicalDeviceCount < physicalDevices.size() )
142 {
143 physicalDevices.resize( physicalDeviceCount );
144 }
145 return detail::createResultValueType( result, std::move( physicalDevices ) );
146 }
147
148 // wrapper function for command vkEnumeratePhysicalDevices, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDevices.html
149 template <typename PhysicalDeviceAllocator,
150 typename Dispatch,
151 typename std::enable_if<std::is_same<typename PhysicalDeviceAllocator::value_type, PhysicalDevice>::value, int>::type,
152 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
153 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<PhysicalDevice, PhysicalDeviceAllocator>>::type
154 Instance::enumeratePhysicalDevices( PhysicalDeviceAllocator & physicalDeviceAllocator, Dispatch const & d ) const
155 {
156 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
157 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
158 VULKAN_HPP_ASSERT( d.vkEnumeratePhysicalDevices && "Function <vkEnumeratePhysicalDevices> requires <VK_VERSION_1_0>" );
159 # endif
160
161 std::vector<PhysicalDevice, PhysicalDeviceAllocator> physicalDevices( physicalDeviceAllocator );
162 uint32_t physicalDeviceCount;
163 Result result;
164 do
165 {
166 result = static_cast<Result>( d.vkEnumeratePhysicalDevices( m_instance, &physicalDeviceCount, nullptr ) );
167 if ( ( result == Result::eSuccess ) && physicalDeviceCount )
168 {
169 physicalDevices.resize( physicalDeviceCount );
170 result = static_cast<Result>(
171 d.vkEnumeratePhysicalDevices( m_instance, &physicalDeviceCount, reinterpret_cast<VkPhysicalDevice *>( physicalDevices.data() ) ) );
172 }
173 } while ( result == Result::eIncomplete );
174 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::enumeratePhysicalDevices" );
175 VULKAN_HPP_ASSERT( physicalDeviceCount <= physicalDevices.size() );
176 if ( physicalDeviceCount < physicalDevices.size() )
177 {
178 physicalDevices.resize( physicalDeviceCount );
179 }
180 return detail::createResultValueType( result, std::move( physicalDevices ) );
181 }
182 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
183
184 // wrapper function for command vkGetPhysicalDeviceFeatures, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures.html
185 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
186 VULKAN_HPP_INLINE void PhysicalDevice::getFeatures( PhysicalDeviceFeatures * pFeatures, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
187 {
188 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
189 d.vkGetPhysicalDeviceFeatures( static_cast<VkPhysicalDevice>( m_physicalDevice ), reinterpret_cast<VkPhysicalDeviceFeatures *>( pFeatures ) );
190 }
191
192 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
193 // wrapper function for command vkGetPhysicalDeviceFeatures, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures.html
194 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
195 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PhysicalDeviceFeatures PhysicalDevice::getFeatures( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
196 {
197 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
198 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
199 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceFeatures && "Function <vkGetPhysicalDeviceFeatures> requires <VK_VERSION_1_0>" );
200 # endif
201
202 PhysicalDeviceFeatures features;
203 d.vkGetPhysicalDeviceFeatures( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures *>( &features ) );
204
205 return features;
206 }
207 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
208
209 // wrapper function for command vkGetPhysicalDeviceFormatProperties, see
210 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties.html
211 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
212 VULKAN_HPP_INLINE void
213 PhysicalDevice::getFormatProperties( Format format, FormatProperties * pFormatProperties, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
214 {
215 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
216 d.vkGetPhysicalDeviceFormatProperties(
217 static_cast<VkPhysicalDevice>( m_physicalDevice ), static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties *>( pFormatProperties ) );
218 }
219
220 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
221 // wrapper function for command vkGetPhysicalDeviceFormatProperties, see
222 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties.html
223 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
224 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE FormatProperties PhysicalDevice::getFormatProperties( Format format, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
225 {
226 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
227 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
228 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceFormatProperties && "Function <vkGetPhysicalDeviceFormatProperties> requires <VK_VERSION_1_0>" );
229 # endif
230
231 FormatProperties formatProperties;
232 d.vkGetPhysicalDeviceFormatProperties( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties *>( &formatProperties ) );
233
234 return formatProperties;
235 }
236 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
237
238 // wrapper function for command vkGetPhysicalDeviceImageFormatProperties, see
239 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties.html
240 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
241 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getImageFormatProperties( Format format,
242 ImageType type,
243 ImageTiling tiling,
244 ImageUsageFlags usage,
245 ImageCreateFlags flags,
246 ImageFormatProperties * pImageFormatProperties,
247 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
248 {
249 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
250 return static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties( static_cast<VkPhysicalDevice>( m_physicalDevice ),
251 static_cast<VkFormat>( format ),
252 static_cast<VkImageType>( type ),
253 static_cast<VkImageTiling>( tiling ),
254 static_cast<VkImageUsageFlags>( usage ),
255 static_cast<VkImageCreateFlags>( flags ),
256 reinterpret_cast<VkImageFormatProperties *>( pImageFormatProperties ) ) );
257 }
258
259 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
260 // wrapper function for command vkGetPhysicalDeviceImageFormatProperties, see
261 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties.html
262 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
263 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<ImageFormatProperties>::type PhysicalDevice::getImageFormatProperties(
264 Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, Dispatch const & d ) const
265 {
266 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
267 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
268 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceImageFormatProperties && "Function <vkGetPhysicalDeviceImageFormatProperties> requires <VK_VERSION_1_0>" );
269 # endif
270
271 ImageFormatProperties imageFormatProperties;
272 Result result = static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties( m_physicalDevice,
273 static_cast<VkFormat>( format ),
274 static_cast<VkImageType>( type ),
275 static_cast<VkImageTiling>( tiling ),
276 static_cast<VkImageUsageFlags>( usage ),
277 static_cast<VkImageCreateFlags>( flags ),
278 reinterpret_cast<VkImageFormatProperties *>( &imageFormatProperties ) ) );
279 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties" );
280
281 return detail::createResultValueType( result, std::move( imageFormatProperties ) );
282 }
283 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
284
285 // wrapper function for command vkGetPhysicalDeviceProperties, see
286 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties.html
287 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
288 VULKAN_HPP_INLINE void PhysicalDevice::getProperties( PhysicalDeviceProperties * pProperties, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
289 {
290 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
291 d.vkGetPhysicalDeviceProperties( static_cast<VkPhysicalDevice>( m_physicalDevice ), reinterpret_cast<VkPhysicalDeviceProperties *>( pProperties ) );
292 }
293
294 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
295 // wrapper function for command vkGetPhysicalDeviceProperties, see
296 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties.html
297 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
298 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PhysicalDeviceProperties PhysicalDevice::getProperties( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
299 {
300 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
301 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
302 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceProperties && "Function <vkGetPhysicalDeviceProperties> requires <VK_VERSION_1_0>" );
303 # endif
304
305 PhysicalDeviceProperties properties;
306 d.vkGetPhysicalDeviceProperties( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties *>( &properties ) );
307
308 return properties;
309 }
310 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
311
312 // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties, see
313 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties.html
314 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
315 VULKAN_HPP_INLINE void PhysicalDevice::getQueueFamilyProperties( uint32_t * pQueueFamilyPropertyCount,
316 QueueFamilyProperties * pQueueFamilyProperties,
317 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
318 {
319 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
320 d.vkGetPhysicalDeviceQueueFamilyProperties(
321 static_cast<VkPhysicalDevice>( m_physicalDevice ), pQueueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties *>( pQueueFamilyProperties ) );
322 }
323
324 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
325 // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties, see
326 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties.html
327 template <typename QueueFamilyPropertiesAllocator,
328 typename Dispatch,
329 typename std::enable_if<std::is_same<typename QueueFamilyPropertiesAllocator::value_type, QueueFamilyProperties>::value, int>::type,
330 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
331 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<QueueFamilyProperties, QueueFamilyPropertiesAllocator>
332 PhysicalDevice::getQueueFamilyProperties( Dispatch const & d ) const
333 {
334 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
335 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
336 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyProperties && "Function <vkGetPhysicalDeviceQueueFamilyProperties> requires <VK_VERSION_1_0>" );
337 # endif
338
339 std::vector<QueueFamilyProperties, QueueFamilyPropertiesAllocator> queueFamilyProperties;
340 uint32_t queueFamilyPropertyCount;
341 d.vkGetPhysicalDeviceQueueFamilyProperties( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
342 queueFamilyProperties.resize( queueFamilyPropertyCount );
343 d.vkGetPhysicalDeviceQueueFamilyProperties(
344 m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties *>( queueFamilyProperties.data() ) );
345
346 VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() );
347 if ( queueFamilyPropertyCount < queueFamilyProperties.size() )
348 {
349 queueFamilyProperties.resize( queueFamilyPropertyCount );
350 }
351 return queueFamilyProperties;
352 }
353
354 // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties, see
355 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties.html
356 template <typename QueueFamilyPropertiesAllocator,
357 typename Dispatch,
358 typename std::enable_if<std::is_same<typename QueueFamilyPropertiesAllocator::value_type, QueueFamilyProperties>::value, int>::type,
359 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
360 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<QueueFamilyProperties, QueueFamilyPropertiesAllocator>
361 PhysicalDevice::getQueueFamilyProperties( QueueFamilyPropertiesAllocator & queueFamilyPropertiesAllocator, Dispatch const & d ) const
362 {
363 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
364 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
365 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyProperties && "Function <vkGetPhysicalDeviceQueueFamilyProperties> requires <VK_VERSION_1_0>" );
366 # endif
367
368 std::vector<QueueFamilyProperties, QueueFamilyPropertiesAllocator> queueFamilyProperties( queueFamilyPropertiesAllocator );
369 uint32_t queueFamilyPropertyCount;
370 d.vkGetPhysicalDeviceQueueFamilyProperties( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
371 queueFamilyProperties.resize( queueFamilyPropertyCount );
372 d.vkGetPhysicalDeviceQueueFamilyProperties(
373 m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties *>( queueFamilyProperties.data() ) );
374
375 VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() );
376 if ( queueFamilyPropertyCount < queueFamilyProperties.size() )
377 {
378 queueFamilyProperties.resize( queueFamilyPropertyCount );
379 }
380 return queueFamilyProperties;
381 }
382 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
383
384 // wrapper function for command vkGetPhysicalDeviceMemoryProperties, see
385 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties.html
386 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
387 VULKAN_HPP_INLINE void PhysicalDevice::getMemoryProperties( PhysicalDeviceMemoryProperties * pMemoryProperties, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
388 {
389 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
390 d.vkGetPhysicalDeviceMemoryProperties( static_cast<VkPhysicalDevice>( m_physicalDevice ),
391 reinterpret_cast<VkPhysicalDeviceMemoryProperties *>( pMemoryProperties ) );
392 }
393
394 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
395 // wrapper function for command vkGetPhysicalDeviceMemoryProperties, see
396 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties.html
397 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
398 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PhysicalDeviceMemoryProperties PhysicalDevice::getMemoryProperties( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
399 {
400 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
401 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
402 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceMemoryProperties && "Function <vkGetPhysicalDeviceMemoryProperties> requires <VK_VERSION_1_0>" );
403 # endif
404
405 PhysicalDeviceMemoryProperties memoryProperties;
406 d.vkGetPhysicalDeviceMemoryProperties( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties *>( &memoryProperties ) );
407
408 return memoryProperties;
409 }
410 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
411
412 // wrapper function for command vkGetInstanceProcAddr, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetInstanceProcAddr.html
413 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
414 VULKAN_HPP_INLINE PFN_vkVoidFunction Instance::getProcAddr( const char * pName, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
415 {
416 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
417 return d.vkGetInstanceProcAddr( static_cast<VkInstance>( m_instance ), pName );
418 }
419
420 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
421 // wrapper function for command vkGetInstanceProcAddr, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetInstanceProcAddr.html
422 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
423 VULKAN_HPP_INLINE PFN_VoidFunction Instance::getProcAddr( const std::string & name, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
424 {
425 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
426 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
427 VULKAN_HPP_ASSERT( d.vkGetInstanceProcAddr && "Function <vkGetInstanceProcAddr> requires <VK_VERSION_1_0>" );
428 # endif
429
430 PFN_vkVoidFunction result = d.vkGetInstanceProcAddr( m_instance, name.c_str() );
431
432 return result;
433 }
434 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
435
436 // wrapper function for command vkGetDeviceProcAddr, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceProcAddr.html
437 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
438 VULKAN_HPP_INLINE PFN_vkVoidFunction Device::getProcAddr( const char * pName, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
439 {
440 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
441 return d.vkGetDeviceProcAddr( static_cast<VkDevice>( m_device ), pName );
442 }
443
444 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
445 // wrapper function for command vkGetDeviceProcAddr, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceProcAddr.html
446 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
447 VULKAN_HPP_INLINE PFN_VoidFunction Device::getProcAddr( const std::string & name, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
448 {
449 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
450 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
451 VULKAN_HPP_ASSERT( d.vkGetDeviceProcAddr && "Function <vkGetDeviceProcAddr> requires <VK_VERSION_1_0>" );
452 # endif
453
454 PFN_vkVoidFunction result = d.vkGetDeviceProcAddr( m_device, name.c_str() );
455
456 return result;
457 }
458 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
459
460 // wrapper function for command vkCreateDevice, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDevice.html
461 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
462 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::createDevice( const DeviceCreateInfo * pCreateInfo,
463 const AllocationCallbacks * pAllocator,
464 Device * pDevice,
465 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
466 {
467 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
468 return static_cast<Result>( d.vkCreateDevice( static_cast<VkPhysicalDevice>( m_physicalDevice ),
469 reinterpret_cast<const VkDeviceCreateInfo *>( pCreateInfo ),
470 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
471 reinterpret_cast<VkDevice *>( pDevice ) ) );
472 }
473
474 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
475 // wrapper function for command vkCreateDevice, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDevice.html
476 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
477 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<Device>::type
478 PhysicalDevice::createDevice( const DeviceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
479 {
480 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
481 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
482 VULKAN_HPP_ASSERT( d.vkCreateDevice && "Function <vkCreateDevice> requires <VK_VERSION_1_0>" );
483 # endif
484
485 Device device;
486 Result result = static_cast<Result>( d.vkCreateDevice( m_physicalDevice,
487 reinterpret_cast<const VkDeviceCreateInfo *>( &createInfo ),
488 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
489 reinterpret_cast<VkDevice *>( &device ) ) );
490 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::createDevice" );
491
492 return detail::createResultValueType( result, std::move( device ) );
493 }
494
495 # ifndef VULKAN_HPP_NO_SMART_HANDLE
496 // wrapper function for command vkCreateDevice, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDevice.html
497 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
498 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Device, Dispatch>>::type
499 PhysicalDevice::createDeviceUnique( const DeviceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
500 {
501 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
502 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
503 VULKAN_HPP_ASSERT( d.vkCreateDevice && "Function <vkCreateDevice> requires <VK_VERSION_1_0>" );
504 # endif
505
506 Device device;
507 Result result = static_cast<Result>( d.vkCreateDevice( m_physicalDevice,
508 reinterpret_cast<const VkDeviceCreateInfo *>( &createInfo ),
509 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
510 reinterpret_cast<VkDevice *>( &device ) ) );
511 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::createDeviceUnique" );
512
513 return detail::createResultValueType( result, UniqueHandle<Device, Dispatch>( device, detail::ObjectDestroy<detail::NoParent, Dispatch>( allocator, d ) ) );
514 }
515 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
516 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
517
518 // wrapper function for command vkDestroyDevice, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDevice.html
519 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
520 VULKAN_HPP_INLINE void Device::destroy( const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
521 {
522 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
523 d.vkDestroyDevice( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
524 }
525
526 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
527 // wrapper function for command vkDestroyDevice, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDevice.html
528 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
529 VULKAN_HPP_INLINE void Device::destroy( Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
530 {
531 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
532 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
533 VULKAN_HPP_ASSERT( d.vkDestroyDevice && "Function <vkDestroyDevice> requires <VK_VERSION_1_0>" );
534 # endif
535
536 d.vkDestroyDevice( m_device, reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
537 }
538 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
539
540 // wrapper function for command vkEnumerateInstanceExtensionProperties, see
541 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceExtensionProperties.html
542 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
543 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result enumerateInstanceExtensionProperties( const char * pLayerName,
544 uint32_t * pPropertyCount,
545 ExtensionProperties * pProperties,
546 Dispatch const & d ) VULKAN_HPP_NOEXCEPT
547 {
548 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
549 return static_cast<Result>(
550 d.vkEnumerateInstanceExtensionProperties( pLayerName, pPropertyCount, reinterpret_cast<VkExtensionProperties *>( pProperties ) ) );
551 }
552
553 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
554 // wrapper function for command vkEnumerateInstanceExtensionProperties, see
555 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceExtensionProperties.html
556 template <typename ExtensionPropertiesAllocator,
557 typename Dispatch,
558 typename std::enable_if<std::is_same<typename ExtensionPropertiesAllocator::value_type, ExtensionProperties>::value, int>::type,
559 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
560 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<ExtensionProperties, ExtensionPropertiesAllocator>>::type
561 enumerateInstanceExtensionProperties( Optional<const std::string> layerName, Dispatch const & d )
562 {
563 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
564 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
565 VULKAN_HPP_ASSERT( d.vkEnumerateInstanceExtensionProperties && "Function <vkEnumerateInstanceExtensionProperties> requires <VK_VERSION_1_0>" );
566 # endif
567
568 std::vector<ExtensionProperties, ExtensionPropertiesAllocator> properties;
569 uint32_t propertyCount;
570 Result result;
571 do
572 {
573 result = static_cast<Result>( d.vkEnumerateInstanceExtensionProperties( layerName ? layerName->c_str() : nullptr, &propertyCount, nullptr ) );
574 if ( ( result == Result::eSuccess ) && propertyCount )
575 {
576 properties.resize( propertyCount );
577 result = static_cast<Result>( d.vkEnumerateInstanceExtensionProperties(
578 layerName ? layerName->c_str() : nullptr, &propertyCount, reinterpret_cast<VkExtensionProperties *>( properties.data() ) ) );
579 }
580 } while ( result == Result::eIncomplete );
581 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::enumerateInstanceExtensionProperties" );
582 VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
583 if ( propertyCount < properties.size() )
584 {
585 properties.resize( propertyCount );
586 }
587 return detail::createResultValueType( result, std::move( properties ) );
588 }
589
590 // wrapper function for command vkEnumerateInstanceExtensionProperties, see
591 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceExtensionProperties.html
592 template <typename ExtensionPropertiesAllocator,
593 typename Dispatch,
594 typename std::enable_if<std::is_same<typename ExtensionPropertiesAllocator::value_type, ExtensionProperties>::value, int>::type,
595 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
596 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<ExtensionProperties, ExtensionPropertiesAllocator>>::type
597 enumerateInstanceExtensionProperties( Optional<const std::string> layerName,
598 ExtensionPropertiesAllocator & extensionPropertiesAllocator,
599 Dispatch const & d )
600 {
601 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
602 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
603 VULKAN_HPP_ASSERT( d.vkEnumerateInstanceExtensionProperties && "Function <vkEnumerateInstanceExtensionProperties> requires <VK_VERSION_1_0>" );
604 # endif
605
606 std::vector<ExtensionProperties, ExtensionPropertiesAllocator> properties( extensionPropertiesAllocator );
607 uint32_t propertyCount;
608 Result result;
609 do
610 {
611 result = static_cast<Result>( d.vkEnumerateInstanceExtensionProperties( layerName ? layerName->c_str() : nullptr, &propertyCount, nullptr ) );
612 if ( ( result == Result::eSuccess ) && propertyCount )
613 {
614 properties.resize( propertyCount );
615 result = static_cast<Result>( d.vkEnumerateInstanceExtensionProperties(
616 layerName ? layerName->c_str() : nullptr, &propertyCount, reinterpret_cast<VkExtensionProperties *>( properties.data() ) ) );
617 }
618 } while ( result == Result::eIncomplete );
619 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::enumerateInstanceExtensionProperties" );
620 VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
621 if ( propertyCount < properties.size() )
622 {
623 properties.resize( propertyCount );
624 }
625 return detail::createResultValueType( result, std::move( properties ) );
626 }
627 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
628
629 // wrapper function for command vkEnumerateDeviceExtensionProperties, see
630 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateDeviceExtensionProperties.html
631 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
632 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::enumerateDeviceExtensionProperties( const char * pLayerName,
633 uint32_t * pPropertyCount,
634 ExtensionProperties * pProperties,
635 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
636 {
637 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
638 return static_cast<Result>( d.vkEnumerateDeviceExtensionProperties(
639 static_cast<VkPhysicalDevice>( m_physicalDevice ), pLayerName, pPropertyCount, reinterpret_cast<VkExtensionProperties *>( pProperties ) ) );
640 }
641
642 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
643 // wrapper function for command vkEnumerateDeviceExtensionProperties, see
644 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateDeviceExtensionProperties.html
645 template <typename ExtensionPropertiesAllocator,
646 typename Dispatch,
647 typename std::enable_if<std::is_same<typename ExtensionPropertiesAllocator::value_type, ExtensionProperties>::value, int>::type,
648 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
649 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<ExtensionProperties, ExtensionPropertiesAllocator>>::type
650 PhysicalDevice::enumerateDeviceExtensionProperties( Optional<const std::string> layerName, Dispatch const & d ) const
651 {
652 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
653 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
654 VULKAN_HPP_ASSERT( d.vkEnumerateDeviceExtensionProperties && "Function <vkEnumerateDeviceExtensionProperties> requires <VK_VERSION_1_0>" );
655 # endif
656
657 std::vector<ExtensionProperties, ExtensionPropertiesAllocator> properties;
658 uint32_t propertyCount;
659 Result result;
660 do
661 {
662 result =
663 static_cast<Result>( d.vkEnumerateDeviceExtensionProperties( m_physicalDevice, layerName ? layerName->c_str() : nullptr, &propertyCount, nullptr ) );
664 if ( ( result == Result::eSuccess ) && propertyCount )
665 {
666 properties.resize( propertyCount );
667 result = static_cast<Result>( d.vkEnumerateDeviceExtensionProperties(
668 m_physicalDevice, layerName ? layerName->c_str() : nullptr, &propertyCount, reinterpret_cast<VkExtensionProperties *>( properties.data() ) ) );
669 }
670 } while ( result == Result::eIncomplete );
671 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateDeviceExtensionProperties" );
672 VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
673 if ( propertyCount < properties.size() )
674 {
675 properties.resize( propertyCount );
676 }
677 return detail::createResultValueType( result, std::move( properties ) );
678 }
679
680 // wrapper function for command vkEnumerateDeviceExtensionProperties, see
681 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateDeviceExtensionProperties.html
682 template <typename ExtensionPropertiesAllocator,
683 typename Dispatch,
684 typename std::enable_if<std::is_same<typename ExtensionPropertiesAllocator::value_type, ExtensionProperties>::value, int>::type,
685 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
686 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<ExtensionProperties, ExtensionPropertiesAllocator>>::type
687 PhysicalDevice::enumerateDeviceExtensionProperties( Optional<const std::string> layerName,
688 ExtensionPropertiesAllocator & extensionPropertiesAllocator,
689 Dispatch const & d ) const
690 {
691 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
692 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
693 VULKAN_HPP_ASSERT( d.vkEnumerateDeviceExtensionProperties && "Function <vkEnumerateDeviceExtensionProperties> requires <VK_VERSION_1_0>" );
694 # endif
695
696 std::vector<ExtensionProperties, ExtensionPropertiesAllocator> properties( extensionPropertiesAllocator );
697 uint32_t propertyCount;
698 Result result;
699 do
700 {
701 result =
702 static_cast<Result>( d.vkEnumerateDeviceExtensionProperties( m_physicalDevice, layerName ? layerName->c_str() : nullptr, &propertyCount, nullptr ) );
703 if ( ( result == Result::eSuccess ) && propertyCount )
704 {
705 properties.resize( propertyCount );
706 result = static_cast<Result>( d.vkEnumerateDeviceExtensionProperties(
707 m_physicalDevice, layerName ? layerName->c_str() : nullptr, &propertyCount, reinterpret_cast<VkExtensionProperties *>( properties.data() ) ) );
708 }
709 } while ( result == Result::eIncomplete );
710 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateDeviceExtensionProperties" );
711 VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
712 if ( propertyCount < properties.size() )
713 {
714 properties.resize( propertyCount );
715 }
716 return detail::createResultValueType( result, std::move( properties ) );
717 }
718 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
719
720 // wrapper function for command vkEnumerateInstanceLayerProperties, see
721 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceLayerProperties.html
722 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
723 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result enumerateInstanceLayerProperties( uint32_t * pPropertyCount,
724 LayerProperties * pProperties,
725 Dispatch const & d ) VULKAN_HPP_NOEXCEPT
726 {
727 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
728 return static_cast<Result>( d.vkEnumerateInstanceLayerProperties( pPropertyCount, reinterpret_cast<VkLayerProperties *>( pProperties ) ) );
729 }
730
731 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
732 // wrapper function for command vkEnumerateInstanceLayerProperties, see
733 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceLayerProperties.html
734 template <typename LayerPropertiesAllocator,
735 typename Dispatch,
736 typename std::enable_if<std::is_same<typename LayerPropertiesAllocator::value_type, LayerProperties>::value, int>::type,
737 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
738 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<LayerProperties, LayerPropertiesAllocator>>::type
739 enumerateInstanceLayerProperties( Dispatch const & d )
740 {
741 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
742 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
743 VULKAN_HPP_ASSERT( d.vkEnumerateInstanceLayerProperties && "Function <vkEnumerateInstanceLayerProperties> requires <VK_VERSION_1_0>" );
744 # endif
745
746 std::vector<LayerProperties, LayerPropertiesAllocator> properties;
747 uint32_t propertyCount;
748 Result result;
749 do
750 {
751 result = static_cast<Result>( d.vkEnumerateInstanceLayerProperties( &propertyCount, nullptr ) );
752 if ( ( result == Result::eSuccess ) && propertyCount )
753 {
754 properties.resize( propertyCount );
755 result = static_cast<Result>( d.vkEnumerateInstanceLayerProperties( &propertyCount, reinterpret_cast<VkLayerProperties *>( properties.data() ) ) );
756 }
757 } while ( result == Result::eIncomplete );
758 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::enumerateInstanceLayerProperties" );
759 VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
760 if ( propertyCount < properties.size() )
761 {
762 properties.resize( propertyCount );
763 }
764 return detail::createResultValueType( result, std::move( properties ) );
765 }
766
767 // wrapper function for command vkEnumerateInstanceLayerProperties, see
768 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceLayerProperties.html
769 template <typename LayerPropertiesAllocator,
770 typename Dispatch,
771 typename std::enable_if<std::is_same<typename LayerPropertiesAllocator::value_type, LayerProperties>::value, int>::type,
772 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
773 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<LayerProperties, LayerPropertiesAllocator>>::type
774 enumerateInstanceLayerProperties( LayerPropertiesAllocator & layerPropertiesAllocator, Dispatch const & d )
775 {
776 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
777 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
778 VULKAN_HPP_ASSERT( d.vkEnumerateInstanceLayerProperties && "Function <vkEnumerateInstanceLayerProperties> requires <VK_VERSION_1_0>" );
779 # endif
780
781 std::vector<LayerProperties, LayerPropertiesAllocator> properties( layerPropertiesAllocator );
782 uint32_t propertyCount;
783 Result result;
784 do
785 {
786 result = static_cast<Result>( d.vkEnumerateInstanceLayerProperties( &propertyCount, nullptr ) );
787 if ( ( result == Result::eSuccess ) && propertyCount )
788 {
789 properties.resize( propertyCount );
790 result = static_cast<Result>( d.vkEnumerateInstanceLayerProperties( &propertyCount, reinterpret_cast<VkLayerProperties *>( properties.data() ) ) );
791 }
792 } while ( result == Result::eIncomplete );
793 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::enumerateInstanceLayerProperties" );
794 VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
795 if ( propertyCount < properties.size() )
796 {
797 properties.resize( propertyCount );
798 }
799 return detail::createResultValueType( result, std::move( properties ) );
800 }
801 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
802
803 // wrapper function for command vkEnumerateDeviceLayerProperties, see
804 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateDeviceLayerProperties.html
805 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
806 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::enumerateDeviceLayerProperties( uint32_t * pPropertyCount,
807 LayerProperties * pProperties,
808 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
809 {
810 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
811 return static_cast<Result>( d.vkEnumerateDeviceLayerProperties(
812 static_cast<VkPhysicalDevice>( m_physicalDevice ), pPropertyCount, reinterpret_cast<VkLayerProperties *>( pProperties ) ) );
813 }
814
815 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
816 // wrapper function for command vkEnumerateDeviceLayerProperties, see
817 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateDeviceLayerProperties.html
818 template <typename LayerPropertiesAllocator,
819 typename Dispatch,
820 typename std::enable_if<std::is_same<typename LayerPropertiesAllocator::value_type, LayerProperties>::value, int>::type,
821 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
822 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<LayerProperties, LayerPropertiesAllocator>>::type
823 PhysicalDevice::enumerateDeviceLayerProperties( Dispatch const & d ) const
824 {
825 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
826 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
827 VULKAN_HPP_ASSERT( d.vkEnumerateDeviceLayerProperties && "Function <vkEnumerateDeviceLayerProperties> requires <VK_VERSION_1_0>" );
828 # endif
829
830 std::vector<LayerProperties, LayerPropertiesAllocator> properties;
831 uint32_t propertyCount;
832 Result result;
833 do
834 {
835 result = static_cast<Result>( d.vkEnumerateDeviceLayerProperties( m_physicalDevice, &propertyCount, nullptr ) );
836 if ( ( result == Result::eSuccess ) && propertyCount )
837 {
838 properties.resize( propertyCount );
839 result = static_cast<Result>(
840 d.vkEnumerateDeviceLayerProperties( m_physicalDevice, &propertyCount, reinterpret_cast<VkLayerProperties *>( properties.data() ) ) );
841 }
842 } while ( result == Result::eIncomplete );
843 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateDeviceLayerProperties" );
844 VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
845 if ( propertyCount < properties.size() )
846 {
847 properties.resize( propertyCount );
848 }
849 return detail::createResultValueType( result, std::move( properties ) );
850 }
851
852 // wrapper function for command vkEnumerateDeviceLayerProperties, see
853 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateDeviceLayerProperties.html
854 template <typename LayerPropertiesAllocator,
855 typename Dispatch,
856 typename std::enable_if<std::is_same<typename LayerPropertiesAllocator::value_type, LayerProperties>::value, int>::type,
857 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
858 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<LayerProperties, LayerPropertiesAllocator>>::type
859 PhysicalDevice::enumerateDeviceLayerProperties( LayerPropertiesAllocator & layerPropertiesAllocator, Dispatch const & d ) const
860 {
861 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
862 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
863 VULKAN_HPP_ASSERT( d.vkEnumerateDeviceLayerProperties && "Function <vkEnumerateDeviceLayerProperties> requires <VK_VERSION_1_0>" );
864 # endif
865
866 std::vector<LayerProperties, LayerPropertiesAllocator> properties( layerPropertiesAllocator );
867 uint32_t propertyCount;
868 Result result;
869 do
870 {
871 result = static_cast<Result>( d.vkEnumerateDeviceLayerProperties( m_physicalDevice, &propertyCount, nullptr ) );
872 if ( ( result == Result::eSuccess ) && propertyCount )
873 {
874 properties.resize( propertyCount );
875 result = static_cast<Result>(
876 d.vkEnumerateDeviceLayerProperties( m_physicalDevice, &propertyCount, reinterpret_cast<VkLayerProperties *>( properties.data() ) ) );
877 }
878 } while ( result == Result::eIncomplete );
879 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateDeviceLayerProperties" );
880 VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
881 if ( propertyCount < properties.size() )
882 {
883 properties.resize( propertyCount );
884 }
885 return detail::createResultValueType( result, std::move( properties ) );
886 }
887 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
888
889 // wrapper function for command vkGetDeviceQueue, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceQueue.html
890 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
891 VULKAN_HPP_INLINE void Device::getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex, Queue * pQueue, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
892 {
893 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
894 d.vkGetDeviceQueue( static_cast<VkDevice>( m_device ), queueFamilyIndex, queueIndex, reinterpret_cast<VkQueue *>( pQueue ) );
895 }
896
897 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
898 // wrapper function for command vkGetDeviceQueue, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceQueue.html
899 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
900 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Queue Device::getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
901 {
902 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
903 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
904 VULKAN_HPP_ASSERT( d.vkGetDeviceQueue && "Function <vkGetDeviceQueue> requires <VK_VERSION_1_0>" );
905 # endif
906
907 Queue queue;
908 d.vkGetDeviceQueue( m_device, queueFamilyIndex, queueIndex, reinterpret_cast<VkQueue *>( &queue ) );
909
910 return queue;
911 }
912 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
913
914 // wrapper function for command vkQueueSubmit, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSubmit.html
915 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
916 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
917 Queue::submit( uint32_t submitCount, const SubmitInfo * pSubmits, Fence fence, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
918 {
919 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
920 return static_cast<Result>(
921 d.vkQueueSubmit( static_cast<VkQueue>( m_queue ), submitCount, reinterpret_cast<const VkSubmitInfo *>( pSubmits ), static_cast<VkFence>( fence ) ) );
922 }
923
924 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
925 // wrapper function for command vkQueueSubmit, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSubmit.html
926 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
927 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
928 Queue::submit( ArrayProxy<const SubmitInfo> const & submits, Fence fence, Dispatch const & d ) const
929 {
930 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
931 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
932 VULKAN_HPP_ASSERT( d.vkQueueSubmit && "Function <vkQueueSubmit> requires <VK_VERSION_1_0>" );
933 # endif
934
935 Result result = static_cast<Result>(
936 d.vkQueueSubmit( m_queue, submits.size(), reinterpret_cast<const VkSubmitInfo *>( submits.data() ), static_cast<VkFence>( fence ) ) );
937 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::submit" );
938
939 return detail::createResultValueType( result );
940 }
941 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
942
943 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
944 // wrapper function for command vkQueueWaitIdle, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueWaitIdle.html
945 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
946 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Queue::waitIdle( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
947 {
948 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
949 return static_cast<Result>( d.vkQueueWaitIdle( static_cast<VkQueue>( m_queue ) ) );
950 }
951 #else
952 // wrapper function for command vkQueueWaitIdle, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueWaitIdle.html
953 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
954 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type Queue::waitIdle( Dispatch const & d ) const
955 {
956 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
957 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
958 VULKAN_HPP_ASSERT( d.vkQueueWaitIdle && "Function <vkQueueWaitIdle> requires <VK_VERSION_1_0>" );
959 # endif
960
961 Result result = static_cast<Result>( d.vkQueueWaitIdle( m_queue ) );
962 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::waitIdle" );
963
964 return detail::createResultValueType( result );
965 }
966 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
967
968 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
969 // wrapper function for command vkDeviceWaitIdle, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDeviceWaitIdle.html
970 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
971 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::waitIdle( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
972 {
973 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
974 return static_cast<Result>( d.vkDeviceWaitIdle( static_cast<VkDevice>( m_device ) ) );
975 }
976 #else
977 // wrapper function for command vkDeviceWaitIdle, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDeviceWaitIdle.html
978 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
979 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::waitIdle( Dispatch const & d ) const
980 {
981 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
982 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
983 VULKAN_HPP_ASSERT( d.vkDeviceWaitIdle && "Function <vkDeviceWaitIdle> requires <VK_VERSION_1_0>" );
984 # endif
985
986 Result result = static_cast<Result>( d.vkDeviceWaitIdle( m_device ) );
987 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::waitIdle" );
988
989 return detail::createResultValueType( result );
990 }
991 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
992
993 // wrapper function for command vkAllocateMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateMemory.html
994 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
995 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::allocateMemory( const MemoryAllocateInfo * pAllocateInfo,
996 const AllocationCallbacks * pAllocator,
997 DeviceMemory * pMemory,
998 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
999 {
1000 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
1001 return static_cast<Result>( d.vkAllocateMemory( static_cast<VkDevice>( m_device ),
1002 reinterpret_cast<const VkMemoryAllocateInfo *>( pAllocateInfo ),
1003 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
1004 reinterpret_cast<VkDeviceMemory *>( pMemory ) ) );
1005 }
1006
1007 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
1008 // wrapper function for command vkAllocateMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateMemory.html
1009 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
1010 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<DeviceMemory>::type
1011 Device::allocateMemory( const MemoryAllocateInfo & allocateInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
1012 {
1013 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
1014 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
1015 VULKAN_HPP_ASSERT( d.vkAllocateMemory && "Function <vkAllocateMemory> requires <VK_VERSION_1_0>" );
1016 # endif
1017
1018 DeviceMemory memory;
1019 Result result = static_cast<Result>( d.vkAllocateMemory( m_device,
1020 reinterpret_cast<const VkMemoryAllocateInfo *>( &allocateInfo ),
1021 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
1022 reinterpret_cast<VkDeviceMemory *>( &memory ) ) );
1023 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateMemory" );
1024
1025 return detail::createResultValueType( result, std::move( memory ) );
1026 }
1027
1028 # ifndef VULKAN_HPP_NO_SMART_HANDLE
1029 // wrapper function for command vkAllocateMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateMemory.html
1030 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
1031 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<DeviceMemory, Dispatch>>::type
1032 Device::allocateMemoryUnique( const MemoryAllocateInfo & allocateInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
1033 {
1034 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
1035 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
1036 VULKAN_HPP_ASSERT( d.vkAllocateMemory && "Function <vkAllocateMemory> requires <VK_VERSION_1_0>" );
1037 # endif
1038
1039 DeviceMemory memory;
1040 Result result = static_cast<Result>( d.vkAllocateMemory( m_device,
1041 reinterpret_cast<const VkMemoryAllocateInfo *>( &allocateInfo ),
1042 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
1043 reinterpret_cast<VkDeviceMemory *>( &memory ) ) );
1044 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateMemoryUnique" );
1045
1046 return detail::createResultValueType( result, UniqueHandle<DeviceMemory, Dispatch>( memory, detail::ObjectFree<Device, Dispatch>( *this, allocator, d ) ) );
1047 }
1048 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
1049 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
1050
1051 // wrapper function for command vkFreeMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeMemory.html
1052 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
1053 VULKAN_HPP_INLINE void Device::freeMemory( DeviceMemory memory, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
1054 {
1055 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
1056 d.vkFreeMemory( static_cast<VkDevice>( m_device ), static_cast<VkDeviceMemory>( memory ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
1057 }
1058
1059 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
1060 // wrapper function for command vkFreeMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeMemory.html
1061 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
1062 VULKAN_HPP_INLINE void Device::freeMemory( DeviceMemory memory, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
1063 {
1064 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
1065 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
1066 VULKAN_HPP_ASSERT( d.vkFreeMemory && "Function <vkFreeMemory> requires <VK_VERSION_1_0>" );
1067 # endif
1068
1069 d.vkFreeMemory( m_device, static_cast<VkDeviceMemory>( memory ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
1070 }
1071 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
1072
1073 // wrapper function for command vkFreeMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeMemory.html
1074 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
1075 VULKAN_HPP_INLINE void( Device::free )( DeviceMemory memory, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
1076 {
1077 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
1078 d.vkFreeMemory( static_cast<VkDevice>( m_device ), static_cast<VkDeviceMemory>( memory ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
1079 }
1080
1081 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
1082 // wrapper function for command vkFreeMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeMemory.html
1083 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
1084 VULKAN_HPP_INLINE void( Device::free )( DeviceMemory memory, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
1085 {
1086 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
1087 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
1088 VULKAN_HPP_ASSERT( d.vkFreeMemory && "Function <vkFreeMemory> requires <VK_VERSION_1_0>" );
1089 # endif
1090
1091 d.vkFreeMemory( m_device, static_cast<VkDeviceMemory>( memory ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
1092 }
1093 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
1094
1095 // wrapper function for command vkMapMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMapMemory.html
1096 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
1097 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::mapMemory(
1098 DeviceMemory memory, DeviceSize offset, DeviceSize size, MemoryMapFlags flags, void ** ppData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
1099 {
1100 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
1101 return static_cast<Result>( d.vkMapMemory( static_cast<VkDevice>( m_device ),
1102 static_cast<VkDeviceMemory>( memory ),
1103 static_cast<VkDeviceSize>( offset ),
1104 static_cast<VkDeviceSize>( size ),
1105 static_cast<VkMemoryMapFlags>( flags ),
1106 ppData ) );
1107 }
1108
1109 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
1110 // wrapper function for command vkMapMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMapMemory.html
1111 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
1112 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<void *>::type
1113 Device::mapMemory( DeviceMemory memory, DeviceSize offset, DeviceSize size, MemoryMapFlags flags, Dispatch const & d ) const
1114 {
1115 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
1116 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
1117 VULKAN_HPP_ASSERT( d.vkMapMemory && "Function <vkMapMemory> requires <VK_VERSION_1_0>" );
1118 # endif
1119
1120 void * pData;
1121 Result result = static_cast<Result>( d.vkMapMemory( m_device,
1122 static_cast<VkDeviceMemory>( memory ),
1123 static_cast<VkDeviceSize>( offset ),
1124 static_cast<VkDeviceSize>( size ),
1125 static_cast<VkMemoryMapFlags>( flags ),
1126 &pData ) );
1127 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::mapMemory" );
1128
1129 return detail::createResultValueType( result, std::move( pData ) );
1130 }
1131 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
1132
1133 // wrapper function for command vkUnmapMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnmapMemory.html
1134 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
1135 VULKAN_HPP_INLINE void Device::unmapMemory( DeviceMemory memory, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
1136 {
1137 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
1138 d.vkUnmapMemory( static_cast<VkDevice>( m_device ), static_cast<VkDeviceMemory>( memory ) );
1139 }
1140
1141 // wrapper function for command vkFlushMappedMemoryRanges, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFlushMappedMemoryRanges.html
1142 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
1143 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::flushMappedMemoryRanges( uint32_t memoryRangeCount,
1144 const MappedMemoryRange * pMemoryRanges,
1145 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
1146 {
1147 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
1148 return static_cast<Result>(
1149 d.vkFlushMappedMemoryRanges( static_cast<VkDevice>( m_device ), memoryRangeCount, reinterpret_cast<const VkMappedMemoryRange *>( pMemoryRanges ) ) );
1150 }
1151
1152 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
1153 // wrapper function for command vkFlushMappedMemoryRanges, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFlushMappedMemoryRanges.html
1154 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
1155 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
1156 Device::flushMappedMemoryRanges( ArrayProxy<const MappedMemoryRange> const & memoryRanges, Dispatch const & d ) const
1157 {
1158 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
1159 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
1160 VULKAN_HPP_ASSERT( d.vkFlushMappedMemoryRanges && "Function <vkFlushMappedMemoryRanges> requires <VK_VERSION_1_0>" );
1161 # endif
1162
1163 Result result =
1164 static_cast<Result>( d.vkFlushMappedMemoryRanges( m_device, memoryRanges.size(), reinterpret_cast<const VkMappedMemoryRange *>( memoryRanges.data() ) ) );
1165 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::flushMappedMemoryRanges" );
1166
1167 return detail::createResultValueType( result );
1168 }
1169 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
1170
1171 // wrapper function for command vkInvalidateMappedMemoryRanges, see
1172 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkInvalidateMappedMemoryRanges.html
1173 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
1174 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::invalidateMappedMemoryRanges( uint32_t memoryRangeCount,
1175 const MappedMemoryRange * pMemoryRanges,
1176 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
1177 {
1178 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
1179 return static_cast<Result>(
1180 d.vkInvalidateMappedMemoryRanges( static_cast<VkDevice>( m_device ), memoryRangeCount, reinterpret_cast<const VkMappedMemoryRange *>( pMemoryRanges ) ) );
1181 }
1182
1183 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
1184 // wrapper function for command vkInvalidateMappedMemoryRanges, see
1185 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkInvalidateMappedMemoryRanges.html
1186 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
1187 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
1188 Device::invalidateMappedMemoryRanges( ArrayProxy<const MappedMemoryRange> const & memoryRanges, Dispatch const & d ) const
1189 {
1190 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
1191 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
1192 VULKAN_HPP_ASSERT( d.vkInvalidateMappedMemoryRanges && "Function <vkInvalidateMappedMemoryRanges> requires <VK_VERSION_1_0>" );
1193 # endif
1194
1195 Result result = static_cast<Result>(
1196 d.vkInvalidateMappedMemoryRanges( m_device, memoryRanges.size(), reinterpret_cast<const VkMappedMemoryRange *>( memoryRanges.data() ) ) );
1197 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::invalidateMappedMemoryRanges" );
1198
1199 return detail::createResultValueType( result );
1200 }
1201 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
1202
1203 // wrapper function for command vkGetDeviceMemoryCommitment, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMemoryCommitment.html
1204 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
1205 VULKAN_HPP_INLINE void Device::getMemoryCommitment( DeviceMemory memory, DeviceSize * pCommittedMemoryInBytes, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
1206 {
1207 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
1208 d.vkGetDeviceMemoryCommitment(
1209 static_cast<VkDevice>( m_device ), static_cast<VkDeviceMemory>( memory ), reinterpret_cast<VkDeviceSize *>( pCommittedMemoryInBytes ) );
1210 }
1211
1212 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
1213 // wrapper function for command vkGetDeviceMemoryCommitment, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMemoryCommitment.html
1214 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
1215 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DeviceSize Device::getMemoryCommitment( DeviceMemory memory, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
1216 {
1217 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
1218 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
1219 VULKAN_HPP_ASSERT( d.vkGetDeviceMemoryCommitment && "Function <vkGetDeviceMemoryCommitment> requires <VK_VERSION_1_0>" );
1220 # endif
1221
1222 DeviceSize committedMemoryInBytes;
1223 d.vkGetDeviceMemoryCommitment( m_device, static_cast<VkDeviceMemory>( memory ), reinterpret_cast<VkDeviceSize *>( &committedMemoryInBytes ) );
1224
1225 return committedMemoryInBytes;
1226 }
1227 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
1228
1229 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
1230 // wrapper function for command vkBindBufferMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindBufferMemory.html
1231 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
1232 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
1233 Device::bindBufferMemory( Buffer buffer, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
1234 {
1235 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
1236 return static_cast<Result>( d.vkBindBufferMemory(
1237 static_cast<VkDevice>( m_device ), static_cast<VkBuffer>( buffer ), static_cast<VkDeviceMemory>( memory ), static_cast<VkDeviceSize>( memoryOffset ) ) );
1238 }
1239 #else
1240 // wrapper function for command vkBindBufferMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindBufferMemory.html
1241 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
1242 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
1243 Device::bindBufferMemory( Buffer buffer, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const & d ) const
1244 {
1245 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
1246 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
1247 VULKAN_HPP_ASSERT( d.vkBindBufferMemory && "Function <vkBindBufferMemory> requires <VK_VERSION_1_0>" );
1248 # endif
1249
1250 Result result = static_cast<Result>(
1251 d.vkBindBufferMemory( m_device, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceMemory>( memory ), static_cast<VkDeviceSize>( memoryOffset ) ) );
1252 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindBufferMemory" );
1253
1254 return detail::createResultValueType( result );
1255 }
1256 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
1257
1258 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
1259 // wrapper function for command vkBindImageMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindImageMemory.html
1260 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
1261 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
1262 Device::bindImageMemory( Image image, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
1263 {
1264 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
1265 return static_cast<Result>( d.vkBindImageMemory(
1266 static_cast<VkDevice>( m_device ), static_cast<VkImage>( image ), static_cast<VkDeviceMemory>( memory ), static_cast<VkDeviceSize>( memoryOffset ) ) );
1267 }
1268 #else
1269 // wrapper function for command vkBindImageMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindImageMemory.html
1270 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
1271 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
1272 Device::bindImageMemory( Image image, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const & d ) const
1273 {
1274 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
1275 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
1276 VULKAN_HPP_ASSERT( d.vkBindImageMemory && "Function <vkBindImageMemory> requires <VK_VERSION_1_0>" );
1277 # endif
1278
1279 Result result = static_cast<Result>(
1280 d.vkBindImageMemory( m_device, static_cast<VkImage>( image ), static_cast<VkDeviceMemory>( memory ), static_cast<VkDeviceSize>( memoryOffset ) ) );
1281 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindImageMemory" );
1282
1283 return detail::createResultValueType( result );
1284 }
1285 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
1286
1287 // wrapper function for command vkGetBufferMemoryRequirements, see
1288 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements.html
1289 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
1290 VULKAN_HPP_INLINE void
1291 Device::getBufferMemoryRequirements( Buffer buffer, MemoryRequirements * pMemoryRequirements, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
1292 {
1293 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
1294 d.vkGetBufferMemoryRequirements(
1295 static_cast<VkDevice>( m_device ), static_cast<VkBuffer>( buffer ), reinterpret_cast<VkMemoryRequirements *>( pMemoryRequirements ) );
1296 }
1297
1298 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
1299 // wrapper function for command vkGetBufferMemoryRequirements, see
1300 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements.html
1301 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
1302 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements Device::getBufferMemoryRequirements( Buffer buffer, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
1303 {
1304 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
1305 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
1306 VULKAN_HPP_ASSERT( d.vkGetBufferMemoryRequirements && "Function <vkGetBufferMemoryRequirements> requires <VK_VERSION_1_0>" );
1307 # endif
1308
1309 MemoryRequirements memoryRequirements;
1310 d.vkGetBufferMemoryRequirements( m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<VkMemoryRequirements *>( &memoryRequirements ) );
1311
1312 return memoryRequirements;
1313 }
1314 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
1315
1316 // wrapper function for command vkGetImageMemoryRequirements, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements.html
1317 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
1318 VULKAN_HPP_INLINE void
1319 Device::getImageMemoryRequirements( Image image, MemoryRequirements * pMemoryRequirements, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
1320 {
1321 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
1322 d.vkGetImageMemoryRequirements(
1323 static_cast<VkDevice>( m_device ), static_cast<VkImage>( image ), reinterpret_cast<VkMemoryRequirements *>( pMemoryRequirements ) );
1324 }
1325
1326 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
1327 // wrapper function for command vkGetImageMemoryRequirements, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements.html
1328 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
1329 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements Device::getImageMemoryRequirements( Image image, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
1330 {
1331 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
1332 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
1333 VULKAN_HPP_ASSERT( d.vkGetImageMemoryRequirements && "Function <vkGetImageMemoryRequirements> requires <VK_VERSION_1_0>" );
1334 # endif
1335
1336 MemoryRequirements memoryRequirements;
1337 d.vkGetImageMemoryRequirements( m_device, static_cast<VkImage>( image ), reinterpret_cast<VkMemoryRequirements *>( &memoryRequirements ) );
1338
1339 return memoryRequirements;
1340 }
1341 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
1342
1343 // wrapper function for command vkGetImageSparseMemoryRequirements, see
1344 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements.html
1345 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
1346 VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirements( Image image,
1347 uint32_t * pSparseMemoryRequirementCount,
1348 SparseImageMemoryRequirements * pSparseMemoryRequirements,
1349 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
1350 {
1351 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
1352 d.vkGetImageSparseMemoryRequirements( static_cast<VkDevice>( m_device ),
1353 static_cast<VkImage>( image ),
1354 pSparseMemoryRequirementCount,
1355 reinterpret_cast<VkSparseImageMemoryRequirements *>( pSparseMemoryRequirements ) );
1356 }
1357
1358 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
1359 // wrapper function for command vkGetImageSparseMemoryRequirements, see
1360 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements.html
1361 template <typename SparseImageMemoryRequirementsAllocator,
1362 typename Dispatch,
1363 typename std::enable_if<std::is_same<typename SparseImageMemoryRequirementsAllocator::value_type, SparseImageMemoryRequirements>::value, int>::type,
1364 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
1365 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator>
1366 Device::getImageSparseMemoryRequirements( Image image, Dispatch const & d ) const
1367 {
1368 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
1369 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
1370 VULKAN_HPP_ASSERT( d.vkGetImageSparseMemoryRequirements && "Function <vkGetImageSparseMemoryRequirements> requires <VK_VERSION_1_0>" );
1371 # endif
1372
1373 std::vector<SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator> sparseMemoryRequirements;
1374 uint32_t sparseMemoryRequirementCount;
1375 d.vkGetImageSparseMemoryRequirements( m_device, static_cast<VkImage>( image ), &sparseMemoryRequirementCount, nullptr );
1376 sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
1377 d.vkGetImageSparseMemoryRequirements( m_device,
1378 static_cast<VkImage>( image ),
1379 &sparseMemoryRequirementCount,
1380 reinterpret_cast<VkSparseImageMemoryRequirements *>( sparseMemoryRequirements.data() ) );
1381
1382 VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() );
1383 if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() )
1384 {
1385 sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
1386 }
1387 return sparseMemoryRequirements;
1388 }
1389
1390 // wrapper function for command vkGetImageSparseMemoryRequirements, see
1391 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements.html
1392 template <typename SparseImageMemoryRequirementsAllocator,
1393 typename Dispatch,
1394 typename std::enable_if<std::is_same<typename SparseImageMemoryRequirementsAllocator::value_type, SparseImageMemoryRequirements>::value, int>::type,
1395 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
1396 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator>
1397 Device::getImageSparseMemoryRequirements( Image image,
1398 SparseImageMemoryRequirementsAllocator & sparseImageMemoryRequirementsAllocator,
1399 Dispatch const & d ) const
1400 {
1401 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
1402 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
1403 VULKAN_HPP_ASSERT( d.vkGetImageSparseMemoryRequirements && "Function <vkGetImageSparseMemoryRequirements> requires <VK_VERSION_1_0>" );
1404 # endif
1405
1406 std::vector<SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator> sparseMemoryRequirements( sparseImageMemoryRequirementsAllocator );
1407 uint32_t sparseMemoryRequirementCount;
1408 d.vkGetImageSparseMemoryRequirements( m_device, static_cast<VkImage>( image ), &sparseMemoryRequirementCount, nullptr );
1409 sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
1410 d.vkGetImageSparseMemoryRequirements( m_device,
1411 static_cast<VkImage>( image ),
1412 &sparseMemoryRequirementCount,
1413 reinterpret_cast<VkSparseImageMemoryRequirements *>( sparseMemoryRequirements.data() ) );
1414
1415 VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() );
1416 if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() )
1417 {
1418 sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
1419 }
1420 return sparseMemoryRequirements;
1421 }
1422 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
1423
1424 // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties, see
1425 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties.html
1426 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
1427 VULKAN_HPP_INLINE void PhysicalDevice::getSparseImageFormatProperties( Format format,
1428 ImageType type,
1429 SampleCountFlagBits samples,
1430 ImageUsageFlags usage,
1431 ImageTiling tiling,
1432 uint32_t * pPropertyCount,
1433 SparseImageFormatProperties * pProperties,
1434 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
1435 {
1436 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
1437 d.vkGetPhysicalDeviceSparseImageFormatProperties( static_cast<VkPhysicalDevice>( m_physicalDevice ),
1438 static_cast<VkFormat>( format ),
1439 static_cast<VkImageType>( type ),
1440 static_cast<VkSampleCountFlagBits>( samples ),
1441 static_cast<VkImageUsageFlags>( usage ),
1442 static_cast<VkImageTiling>( tiling ),
1443 pPropertyCount,
1444 reinterpret_cast<VkSparseImageFormatProperties *>( pProperties ) );
1445 }
1446
1447 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
1448 // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties, see
1449 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties.html
1450 template <typename SparseImageFormatPropertiesAllocator,
1451 typename Dispatch,
1452 typename std::enable_if<std::is_same<typename SparseImageFormatPropertiesAllocator::value_type, SparseImageFormatProperties>::value, int>::type,
1453 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
1454 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties, SparseImageFormatPropertiesAllocator>
1455 PhysicalDevice::getSparseImageFormatProperties(
1456 Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling, Dispatch const & d ) const
1457 {
1458 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
1459 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
1460 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSparseImageFormatProperties &&
1461 "Function <vkGetPhysicalDeviceSparseImageFormatProperties> requires <VK_VERSION_1_0>" );
1462 # endif
1463
1464 std::vector<SparseImageFormatProperties, SparseImageFormatPropertiesAllocator> properties;
1465 uint32_t propertyCount;
1466 d.vkGetPhysicalDeviceSparseImageFormatProperties( m_physicalDevice,
1467 static_cast<VkFormat>( format ),
1468 static_cast<VkImageType>( type ),
1469 static_cast<VkSampleCountFlagBits>( samples ),
1470 static_cast<VkImageUsageFlags>( usage ),
1471 static_cast<VkImageTiling>( tiling ),
1472 &propertyCount,
1473 nullptr );
1474 properties.resize( propertyCount );
1475 d.vkGetPhysicalDeviceSparseImageFormatProperties( m_physicalDevice,
1476 static_cast<VkFormat>( format ),
1477 static_cast<VkImageType>( type ),
1478 static_cast<VkSampleCountFlagBits>( samples ),
1479 static_cast<VkImageUsageFlags>( usage ),
1480 static_cast<VkImageTiling>( tiling ),
1481 &propertyCount,
1482 reinterpret_cast<VkSparseImageFormatProperties *>( properties.data() ) );
1483
1484 VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
1485 if ( propertyCount < properties.size() )
1486 {
1487 properties.resize( propertyCount );
1488 }
1489 return properties;
1490 }
1491
1492 // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties, see
1493 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties.html
1494 template <typename SparseImageFormatPropertiesAllocator,
1495 typename Dispatch,
1496 typename std::enable_if<std::is_same<typename SparseImageFormatPropertiesAllocator::value_type, SparseImageFormatProperties>::value, int>::type,
1497 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
1498 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties, SparseImageFormatPropertiesAllocator>
1499 PhysicalDevice::getSparseImageFormatProperties( Format format,
1500 ImageType type,
1501 SampleCountFlagBits samples,
1502 ImageUsageFlags usage,
1503 ImageTiling tiling,
1504 SparseImageFormatPropertiesAllocator & sparseImageFormatPropertiesAllocator,
1505 Dispatch const & d ) const
1506 {
1507 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
1508 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
1509 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSparseImageFormatProperties &&
1510 "Function <vkGetPhysicalDeviceSparseImageFormatProperties> requires <VK_VERSION_1_0>" );
1511 # endif
1512
1513 std::vector<SparseImageFormatProperties, SparseImageFormatPropertiesAllocator> properties( sparseImageFormatPropertiesAllocator );
1514 uint32_t propertyCount;
1515 d.vkGetPhysicalDeviceSparseImageFormatProperties( m_physicalDevice,
1516 static_cast<VkFormat>( format ),
1517 static_cast<VkImageType>( type ),
1518 static_cast<VkSampleCountFlagBits>( samples ),
1519 static_cast<VkImageUsageFlags>( usage ),
1520 static_cast<VkImageTiling>( tiling ),
1521 &propertyCount,
1522 nullptr );
1523 properties.resize( propertyCount );
1524 d.vkGetPhysicalDeviceSparseImageFormatProperties( m_physicalDevice,
1525 static_cast<VkFormat>( format ),
1526 static_cast<VkImageType>( type ),
1527 static_cast<VkSampleCountFlagBits>( samples ),
1528 static_cast<VkImageUsageFlags>( usage ),
1529 static_cast<VkImageTiling>( tiling ),
1530 &propertyCount,
1531 reinterpret_cast<VkSparseImageFormatProperties *>( properties.data() ) );
1532
1533 VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
1534 if ( propertyCount < properties.size() )
1535 {
1536 properties.resize( propertyCount );
1537 }
1538 return properties;
1539 }
1540 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
1541
1542 // wrapper function for command vkQueueBindSparse, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueBindSparse.html
1543 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
1544 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
1545 Queue::bindSparse( uint32_t bindInfoCount, const BindSparseInfo * pBindInfo, Fence fence, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
1546 {
1547 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
1548 return static_cast<Result>( d.vkQueueBindSparse(
1549 static_cast<VkQueue>( m_queue ), bindInfoCount, reinterpret_cast<const VkBindSparseInfo *>( pBindInfo ), static_cast<VkFence>( fence ) ) );
1550 }
1551
1552 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
1553 // wrapper function for command vkQueueBindSparse, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueBindSparse.html
1554 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
1555 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
1556 Queue::bindSparse( ArrayProxy<const BindSparseInfo> const & bindInfo, Fence fence, Dispatch const & d ) const
1557 {
1558 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
1559 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
1560 VULKAN_HPP_ASSERT( d.vkQueueBindSparse && "Function <vkQueueBindSparse> requires <VK_VERSION_1_0>" );
1561 # endif
1562
1563 Result result = static_cast<Result>(
1564 d.vkQueueBindSparse( m_queue, bindInfo.size(), reinterpret_cast<const VkBindSparseInfo *>( bindInfo.data() ), static_cast<VkFence>( fence ) ) );
1565 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::bindSparse" );
1566
1567 return detail::createResultValueType( result );
1568 }
1569 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
1570
1571 // wrapper function for command vkCreateFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateFence.html
1572 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
1573 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createFence( const FenceCreateInfo * pCreateInfo,
1574 const AllocationCallbacks * pAllocator,
1575 Fence * pFence,
1576 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
1577 {
1578 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
1579 return static_cast<Result>( d.vkCreateFence( static_cast<VkDevice>( m_device ),
1580 reinterpret_cast<const VkFenceCreateInfo *>( pCreateInfo ),
1581 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
1582 reinterpret_cast<VkFence *>( pFence ) ) );
1583 }
1584
1585 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
1586 // wrapper function for command vkCreateFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateFence.html
1587 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
1588 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<Fence>::type
1589 Device::createFence( const FenceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
1590 {
1591 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
1592 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
1593 VULKAN_HPP_ASSERT( d.vkCreateFence && "Function <vkCreateFence> requires <VK_VERSION_1_0>" );
1594 # endif
1595
1596 Fence fence;
1597 Result result = static_cast<Result>( d.vkCreateFence( m_device,
1598 reinterpret_cast<const VkFenceCreateInfo *>( &createInfo ),
1599 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
1600 reinterpret_cast<VkFence *>( &fence ) ) );
1601 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createFence" );
1602
1603 return detail::createResultValueType( result, std::move( fence ) );
1604 }
1605
1606 # ifndef VULKAN_HPP_NO_SMART_HANDLE
1607 // wrapper function for command vkCreateFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateFence.html
1608 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
1609 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Fence, Dispatch>>::type
1610 Device::createFenceUnique( const FenceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
1611 {
1612 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
1613 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
1614 VULKAN_HPP_ASSERT( d.vkCreateFence && "Function <vkCreateFence> requires <VK_VERSION_1_0>" );
1615 # endif
1616
1617 Fence fence;
1618 Result result = static_cast<Result>( d.vkCreateFence( m_device,
1619 reinterpret_cast<const VkFenceCreateInfo *>( &createInfo ),
1620 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
1621 reinterpret_cast<VkFence *>( &fence ) ) );
1622 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createFenceUnique" );
1623
1624 return detail::createResultValueType( result, UniqueHandle<Fence, Dispatch>( fence, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
1625 }
1626 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
1627 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
1628
1629 // wrapper function for command vkDestroyFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyFence.html
1630 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
1631 VULKAN_HPP_INLINE void Device::destroyFence( Fence fence, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
1632 {
1633 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
1634 d.vkDestroyFence( static_cast<VkDevice>( m_device ), static_cast<VkFence>( fence ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
1635 }
1636
1637 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
1638 // wrapper function for command vkDestroyFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyFence.html
1639 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
1640 VULKAN_HPP_INLINE void Device::destroyFence( Fence fence, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
1641 {
1642 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
1643 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
1644 VULKAN_HPP_ASSERT( d.vkDestroyFence && "Function <vkDestroyFence> requires <VK_VERSION_1_0>" );
1645 # endif
1646
1647 d.vkDestroyFence( m_device, static_cast<VkFence>( fence ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
1648 }
1649 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
1650
1651 // wrapper function for command vkDestroyFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyFence.html
1652 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
1653 VULKAN_HPP_INLINE void Device::destroy( Fence fence, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
1654 {
1655 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
1656 d.vkDestroyFence( static_cast<VkDevice>( m_device ), static_cast<VkFence>( fence ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
1657 }
1658
1659 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
1660 // wrapper function for command vkDestroyFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyFence.html
1661 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
1662 VULKAN_HPP_INLINE void Device::destroy( Fence fence, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
1663 {
1664 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
1665 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
1666 VULKAN_HPP_ASSERT( d.vkDestroyFence && "Function <vkDestroyFence> requires <VK_VERSION_1_0>" );
1667 # endif
1668
1669 d.vkDestroyFence( m_device, static_cast<VkFence>( fence ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
1670 }
1671 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
1672
1673 // wrapper function for command vkResetFences, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetFences.html
1674 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
1675 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::resetFences( uint32_t fenceCount, const Fence * pFences, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
1676 {
1677 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
1678 return static_cast<Result>( d.vkResetFences( static_cast<VkDevice>( m_device ), fenceCount, reinterpret_cast<const VkFence *>( pFences ) ) );
1679 }
1680
1681 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
1682 // wrapper function for command vkResetFences, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetFences.html
1683 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
1684 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::resetFences( ArrayProxy<const Fence> const & fences,
1685 Dispatch const & d ) const
1686 {
1687 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
1688 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
1689 VULKAN_HPP_ASSERT( d.vkResetFences && "Function <vkResetFences> requires <VK_VERSION_1_0>" );
1690 # endif
1691
1692 Result result = static_cast<Result>( d.vkResetFences( m_device, fences.size(), reinterpret_cast<const VkFence *>( fences.data() ) ) );
1693 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::resetFences" );
1694
1695 return detail::createResultValueType( result );
1696 }
1697 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
1698
1699 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
1700 // wrapper function for command vkGetFenceStatus, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFenceStatus.html
1701 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
1702 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getFenceStatus( Fence fence, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
1703 {
1704 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
1705 return static_cast<Result>( d.vkGetFenceStatus( static_cast<VkDevice>( m_device ), static_cast<VkFence>( fence ) ) );
1706 }
1707 #else
1708 // wrapper function for command vkGetFenceStatus, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFenceStatus.html
1709 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
1710 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getFenceStatus( Fence fence, Dispatch const & d ) const
1711 {
1712 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
1713 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
1714 VULKAN_HPP_ASSERT( d.vkGetFenceStatus && "Function <vkGetFenceStatus> requires <VK_VERSION_1_0>" );
1715 # endif
1716
1717 Result result = static_cast<Result>( d.vkGetFenceStatus( m_device, static_cast<VkFence>( fence ) ) );
1718 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getFenceStatus", { Result::eSuccess, Result::eNotReady } );
1719
1720 return static_cast<Result>( result );
1721 }
1722 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
1723
1724 // wrapper function for command vkWaitForFences, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitForFences.html
1725 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
1726 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
1727 Device::waitForFences( uint32_t fenceCount, const Fence * pFences, Bool32 waitAll, uint64_t timeout, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
1728 {
1729 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
1730 return static_cast<Result>( d.vkWaitForFences(
1731 static_cast<VkDevice>( m_device ), fenceCount, reinterpret_cast<const VkFence *>( pFences ), static_cast<VkBool32>( waitAll ), timeout ) );
1732 }
1733
1734 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
1735 // wrapper function for command vkWaitForFences, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitForFences.html
1736 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
1737 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
1738 Device::waitForFences( ArrayProxy<const Fence> const & fences, Bool32 waitAll, uint64_t timeout, Dispatch const & d ) const
1739 {
1740 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
1741 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
1742 VULKAN_HPP_ASSERT( d.vkWaitForFences && "Function <vkWaitForFences> requires <VK_VERSION_1_0>" );
1743 # endif
1744
1745 Result result = static_cast<Result>(
1746 d.vkWaitForFences( m_device, fences.size(), reinterpret_cast<const VkFence *>( fences.data() ), static_cast<VkBool32>( waitAll ), timeout ) );
1747 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::waitForFences", { Result::eSuccess, Result::eTimeout } );
1748
1749 return static_cast<Result>( result );
1750 }
1751 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
1752
1753 // wrapper function for command vkCreateSemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSemaphore.html
1754 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
1755 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createSemaphore( const SemaphoreCreateInfo * pCreateInfo,
1756 const AllocationCallbacks * pAllocator,
1757 Semaphore * pSemaphore,
1758 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
1759 {
1760 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
1761 return static_cast<Result>( d.vkCreateSemaphore( static_cast<VkDevice>( m_device ),
1762 reinterpret_cast<const VkSemaphoreCreateInfo *>( pCreateInfo ),
1763 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
1764 reinterpret_cast<VkSemaphore *>( pSemaphore ) ) );
1765 }
1766
1767 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
1768 // wrapper function for command vkCreateSemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSemaphore.html
1769 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
1770 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<Semaphore>::type
1771 Device::createSemaphore( const SemaphoreCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
1772 {
1773 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
1774 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
1775 VULKAN_HPP_ASSERT( d.vkCreateSemaphore && "Function <vkCreateSemaphore> requires <VK_VERSION_1_0>" );
1776 # endif
1777
1778 Semaphore semaphore;
1779 Result result = static_cast<Result>( d.vkCreateSemaphore( m_device,
1780 reinterpret_cast<const VkSemaphoreCreateInfo *>( &createInfo ),
1781 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
1782 reinterpret_cast<VkSemaphore *>( &semaphore ) ) );
1783 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSemaphore" );
1784
1785 return detail::createResultValueType( result, std::move( semaphore ) );
1786 }
1787
1788 # ifndef VULKAN_HPP_NO_SMART_HANDLE
1789 // wrapper function for command vkCreateSemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSemaphore.html
1790 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
1791 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Semaphore, Dispatch>>::type
1792 Device::createSemaphoreUnique( const SemaphoreCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
1793 {
1794 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
1795 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
1796 VULKAN_HPP_ASSERT( d.vkCreateSemaphore && "Function <vkCreateSemaphore> requires <VK_VERSION_1_0>" );
1797 # endif
1798
1799 Semaphore semaphore;
1800 Result result = static_cast<Result>( d.vkCreateSemaphore( m_device,
1801 reinterpret_cast<const VkSemaphoreCreateInfo *>( &createInfo ),
1802 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
1803 reinterpret_cast<VkSemaphore *>( &semaphore ) ) );
1804 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSemaphoreUnique" );
1805
1806 return detail::createResultValueType( result,
1807 UniqueHandle<Semaphore, Dispatch>( semaphore, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
1808 }
1809 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
1810 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
1811
1812 // wrapper function for command vkDestroySemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySemaphore.html
1813 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
1814 VULKAN_HPP_INLINE void Device::destroySemaphore( Semaphore semaphore, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
1815 {
1816 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
1817 d.vkDestroySemaphore(
1818 static_cast<VkDevice>( m_device ), static_cast<VkSemaphore>( semaphore ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
1819 }
1820
1821 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
1822 // wrapper function for command vkDestroySemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySemaphore.html
1823 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
1824 VULKAN_HPP_INLINE void
1825 Device::destroySemaphore( Semaphore semaphore, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
1826 {
1827 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
1828 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
1829 VULKAN_HPP_ASSERT( d.vkDestroySemaphore && "Function <vkDestroySemaphore> requires <VK_VERSION_1_0>" );
1830 # endif
1831
1832 d.vkDestroySemaphore( m_device, static_cast<VkSemaphore>( semaphore ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
1833 }
1834 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
1835
1836 // wrapper function for command vkDestroySemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySemaphore.html
1837 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
1838 VULKAN_HPP_INLINE void Device::destroy( Semaphore semaphore, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
1839 {
1840 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
1841 d.vkDestroySemaphore(
1842 static_cast<VkDevice>( m_device ), static_cast<VkSemaphore>( semaphore ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
1843 }
1844
1845 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
1846 // wrapper function for command vkDestroySemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySemaphore.html
1847 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
1848 VULKAN_HPP_INLINE void Device::destroy( Semaphore semaphore, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
1849 {
1850 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
1851 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
1852 VULKAN_HPP_ASSERT( d.vkDestroySemaphore && "Function <vkDestroySemaphore> requires <VK_VERSION_1_0>" );
1853 # endif
1854
1855 d.vkDestroySemaphore( m_device, static_cast<VkSemaphore>( semaphore ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
1856 }
1857 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
1858
1859 // wrapper function for command vkCreateQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateQueryPool.html
1860 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
1861 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createQueryPool( const QueryPoolCreateInfo * pCreateInfo,
1862 const AllocationCallbacks * pAllocator,
1863 QueryPool * pQueryPool,
1864 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
1865 {
1866 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
1867 return static_cast<Result>( d.vkCreateQueryPool( static_cast<VkDevice>( m_device ),
1868 reinterpret_cast<const VkQueryPoolCreateInfo *>( pCreateInfo ),
1869 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
1870 reinterpret_cast<VkQueryPool *>( pQueryPool ) ) );
1871 }
1872
1873 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
1874 // wrapper function for command vkCreateQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateQueryPool.html
1875 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
1876 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<QueryPool>::type
1877 Device::createQueryPool( const QueryPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
1878 {
1879 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
1880 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
1881 VULKAN_HPP_ASSERT( d.vkCreateQueryPool && "Function <vkCreateQueryPool> requires <VK_VERSION_1_0>" );
1882 # endif
1883
1884 QueryPool queryPool;
1885 Result result = static_cast<Result>( d.vkCreateQueryPool( m_device,
1886 reinterpret_cast<const VkQueryPoolCreateInfo *>( &createInfo ),
1887 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
1888 reinterpret_cast<VkQueryPool *>( &queryPool ) ) );
1889 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createQueryPool" );
1890
1891 return detail::createResultValueType( result, std::move( queryPool ) );
1892 }
1893
1894 # ifndef VULKAN_HPP_NO_SMART_HANDLE
1895 // wrapper function for command vkCreateQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateQueryPool.html
1896 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
1897 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<QueryPool, Dispatch>>::type
1898 Device::createQueryPoolUnique( const QueryPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
1899 {
1900 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
1901 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
1902 VULKAN_HPP_ASSERT( d.vkCreateQueryPool && "Function <vkCreateQueryPool> requires <VK_VERSION_1_0>" );
1903 # endif
1904
1905 QueryPool queryPool;
1906 Result result = static_cast<Result>( d.vkCreateQueryPool( m_device,
1907 reinterpret_cast<const VkQueryPoolCreateInfo *>( &createInfo ),
1908 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
1909 reinterpret_cast<VkQueryPool *>( &queryPool ) ) );
1910 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createQueryPoolUnique" );
1911
1912 return detail::createResultValueType( result,
1913 UniqueHandle<QueryPool, Dispatch>( queryPool, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
1914 }
1915 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
1916 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
1917
1918 // wrapper function for command vkDestroyQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyQueryPool.html
1919 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
1920 VULKAN_HPP_INLINE void Device::destroyQueryPool( QueryPool queryPool, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
1921 {
1922 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
1923 d.vkDestroyQueryPool(
1924 static_cast<VkDevice>( m_device ), static_cast<VkQueryPool>( queryPool ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
1925 }
1926
1927 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
1928 // wrapper function for command vkDestroyQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyQueryPool.html
1929 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
1930 VULKAN_HPP_INLINE void
1931 Device::destroyQueryPool( QueryPool queryPool, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
1932 {
1933 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
1934 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
1935 VULKAN_HPP_ASSERT( d.vkDestroyQueryPool && "Function <vkDestroyQueryPool> requires <VK_VERSION_1_0>" );
1936 # endif
1937
1938 d.vkDestroyQueryPool( m_device, static_cast<VkQueryPool>( queryPool ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
1939 }
1940 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
1941
1942 // wrapper function for command vkDestroyQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyQueryPool.html
1943 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
1944 VULKAN_HPP_INLINE void Device::destroy( QueryPool queryPool, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
1945 {
1946 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
1947 d.vkDestroyQueryPool(
1948 static_cast<VkDevice>( m_device ), static_cast<VkQueryPool>( queryPool ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
1949 }
1950
1951 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
1952 // wrapper function for command vkDestroyQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyQueryPool.html
1953 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
1954 VULKAN_HPP_INLINE void Device::destroy( QueryPool queryPool, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
1955 {
1956 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
1957 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
1958 VULKAN_HPP_ASSERT( d.vkDestroyQueryPool && "Function <vkDestroyQueryPool> requires <VK_VERSION_1_0>" );
1959 # endif
1960
1961 d.vkDestroyQueryPool( m_device, static_cast<VkQueryPool>( queryPool ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
1962 }
1963 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
1964
1965 // wrapper function for command vkGetQueryPoolResults, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueryPoolResults.html
1966 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
1967 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getQueryPoolResults( QueryPool queryPool,
1968 uint32_t firstQuery,
1969 uint32_t queryCount,
1970 size_t dataSize,
1971 void * pData,
1972 DeviceSize stride,
1973 QueryResultFlags flags,
1974 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
1975 {
1976 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
1977 return static_cast<Result>( d.vkGetQueryPoolResults( static_cast<VkDevice>( m_device ),
1978 static_cast<VkQueryPool>( queryPool ),
1979 firstQuery,
1980 queryCount,
1981 dataSize,
1982 pData,
1983 static_cast<VkDeviceSize>( stride ),
1984 static_cast<VkQueryResultFlags>( flags ) ) );
1985 }
1986
1987 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
1988 // wrapper function for command vkGetQueryPoolResults, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueryPoolResults.html
1989 template <typename DataType,
1990 typename DataTypeAllocator,
1991 typename Dispatch,
1992 typename std::enable_if<std::is_same<typename DataTypeAllocator::value_type, DataType>::value, int>::type,
1993 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
1994 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<DataType, DataTypeAllocator>> Device::getQueryPoolResults(
1995 QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, DeviceSize stride, QueryResultFlags flags, Dispatch const & d ) const
1996 {
1997 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
1998 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
1999 VULKAN_HPP_ASSERT( d.vkGetQueryPoolResults && "Function <vkGetQueryPoolResults> requires <VK_VERSION_1_0>" );
2000 # endif
2001
2002 VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 );
2003 std::vector<DataType, DataTypeAllocator> data( dataSize / sizeof( DataType ) );
2004 Result result = static_cast<Result>( d.vkGetQueryPoolResults( m_device,
2005 static_cast<VkQueryPool>( queryPool ),
2006 firstQuery,
2007 queryCount,
2008 data.size() * sizeof( DataType ),
2009 reinterpret_cast<void *>( data.data() ),
2010 static_cast<VkDeviceSize>( stride ),
2011 static_cast<VkQueryResultFlags>( flags ) ) );
2012 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getQueryPoolResults", { Result::eSuccess, Result::eNotReady } );
2013
2014 return ResultValue<std::vector<DataType, DataTypeAllocator>>( result, std::move( data ) );
2015 }
2016
2017 // wrapper function for command vkGetQueryPoolResults, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueryPoolResults.html
2018 template <typename DataType, typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
2019 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<DataType> Device::getQueryPoolResult(
2020 QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, DeviceSize stride, QueryResultFlags flags, Dispatch const & d ) const
2021 {
2022 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
2023 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
2024 VULKAN_HPP_ASSERT( d.vkGetQueryPoolResults && "Function <vkGetQueryPoolResults> requires <VK_VERSION_1_0>" );
2025 # endif
2026
2027 DataType data;
2028 Result result = static_cast<Result>( d.vkGetQueryPoolResults( m_device,
2029 static_cast<VkQueryPool>( queryPool ),
2030 firstQuery,
2031 queryCount,
2032 sizeof( DataType ),
2033 reinterpret_cast<void *>( &data ),
2034 static_cast<VkDeviceSize>( stride ),
2035 static_cast<VkQueryResultFlags>( flags ) ) );
2036 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getQueryPoolResult", { Result::eSuccess, Result::eNotReady } );
2037
2038 return ResultValue<DataType>( result, std::move( data ) );
2039 }
2040 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2041
2042 // wrapper function for command vkCreateBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBuffer.html
2043 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
2044 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createBuffer( const BufferCreateInfo * pCreateInfo,
2045 const AllocationCallbacks * pAllocator,
2046 Buffer * pBuffer,
2047 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
2048 {
2049 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
2050 return static_cast<Result>( d.vkCreateBuffer( static_cast<VkDevice>( m_device ),
2051 reinterpret_cast<const VkBufferCreateInfo *>( pCreateInfo ),
2052 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
2053 reinterpret_cast<VkBuffer *>( pBuffer ) ) );
2054 }
2055
2056 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2057 // wrapper function for command vkCreateBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBuffer.html
2058 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
2059 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<Buffer>::type
2060 Device::createBuffer( const BufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
2061 {
2062 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
2063 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
2064 VULKAN_HPP_ASSERT( d.vkCreateBuffer && "Function <vkCreateBuffer> requires <VK_VERSION_1_0>" );
2065 # endif
2066
2067 Buffer buffer;
2068 Result result = static_cast<Result>( d.vkCreateBuffer( m_device,
2069 reinterpret_cast<const VkBufferCreateInfo *>( &createInfo ),
2070 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
2071 reinterpret_cast<VkBuffer *>( &buffer ) ) );
2072 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createBuffer" );
2073
2074 return detail::createResultValueType( result, std::move( buffer ) );
2075 }
2076
2077 # ifndef VULKAN_HPP_NO_SMART_HANDLE
2078 // wrapper function for command vkCreateBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBuffer.html
2079 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
2080 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Buffer, Dispatch>>::type
2081 Device::createBufferUnique( const BufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
2082 {
2083 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
2084 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
2085 VULKAN_HPP_ASSERT( d.vkCreateBuffer && "Function <vkCreateBuffer> requires <VK_VERSION_1_0>" );
2086 # endif
2087
2088 Buffer buffer;
2089 Result result = static_cast<Result>( d.vkCreateBuffer( m_device,
2090 reinterpret_cast<const VkBufferCreateInfo *>( &createInfo ),
2091 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
2092 reinterpret_cast<VkBuffer *>( &buffer ) ) );
2093 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createBufferUnique" );
2094
2095 return detail::createResultValueType( result, UniqueHandle<Buffer, Dispatch>( buffer, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
2096 }
2097 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
2098 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2099
2100 // wrapper function for command vkDestroyBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBuffer.html
2101 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
2102 VULKAN_HPP_INLINE void Device::destroyBuffer( Buffer buffer, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
2103 {
2104 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
2105 d.vkDestroyBuffer( static_cast<VkDevice>( m_device ), static_cast<VkBuffer>( buffer ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
2106 }
2107
2108 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2109 // wrapper function for command vkDestroyBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBuffer.html
2110 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
2111 VULKAN_HPP_INLINE void Device::destroyBuffer( Buffer buffer, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
2112 {
2113 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
2114 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
2115 VULKAN_HPP_ASSERT( d.vkDestroyBuffer && "Function <vkDestroyBuffer> requires <VK_VERSION_1_0>" );
2116 # endif
2117
2118 d.vkDestroyBuffer( m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
2119 }
2120 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2121
2122 // wrapper function for command vkDestroyBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBuffer.html
2123 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
2124 VULKAN_HPP_INLINE void Device::destroy( Buffer buffer, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
2125 {
2126 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
2127 d.vkDestroyBuffer( static_cast<VkDevice>( m_device ), static_cast<VkBuffer>( buffer ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
2128 }
2129
2130 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2131 // wrapper function for command vkDestroyBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBuffer.html
2132 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
2133 VULKAN_HPP_INLINE void Device::destroy( Buffer buffer, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
2134 {
2135 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
2136 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
2137 VULKAN_HPP_ASSERT( d.vkDestroyBuffer && "Function <vkDestroyBuffer> requires <VK_VERSION_1_0>" );
2138 # endif
2139
2140 d.vkDestroyBuffer( m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
2141 }
2142 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2143
2144 // wrapper function for command vkCreateImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImage.html
2145 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
2146 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createImage( const ImageCreateInfo * pCreateInfo,
2147 const AllocationCallbacks * pAllocator,
2148 Image * pImage,
2149 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
2150 {
2151 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
2152 return static_cast<Result>( d.vkCreateImage( static_cast<VkDevice>( m_device ),
2153 reinterpret_cast<const VkImageCreateInfo *>( pCreateInfo ),
2154 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
2155 reinterpret_cast<VkImage *>( pImage ) ) );
2156 }
2157
2158 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2159 // wrapper function for command vkCreateImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImage.html
2160 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
2161 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<Image>::type
2162 Device::createImage( const ImageCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
2163 {
2164 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
2165 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
2166 VULKAN_HPP_ASSERT( d.vkCreateImage && "Function <vkCreateImage> requires <VK_VERSION_1_0>" );
2167 # endif
2168
2169 Image image;
2170 Result result = static_cast<Result>( d.vkCreateImage( m_device,
2171 reinterpret_cast<const VkImageCreateInfo *>( &createInfo ),
2172 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
2173 reinterpret_cast<VkImage *>( &image ) ) );
2174 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createImage" );
2175
2176 return detail::createResultValueType( result, std::move( image ) );
2177 }
2178
2179 # ifndef VULKAN_HPP_NO_SMART_HANDLE
2180 // wrapper function for command vkCreateImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImage.html
2181 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
2182 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Image, Dispatch>>::type
2183 Device::createImageUnique( const ImageCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
2184 {
2185 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
2186 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
2187 VULKAN_HPP_ASSERT( d.vkCreateImage && "Function <vkCreateImage> requires <VK_VERSION_1_0>" );
2188 # endif
2189
2190 Image image;
2191 Result result = static_cast<Result>( d.vkCreateImage( m_device,
2192 reinterpret_cast<const VkImageCreateInfo *>( &createInfo ),
2193 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
2194 reinterpret_cast<VkImage *>( &image ) ) );
2195 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createImageUnique" );
2196
2197 return detail::createResultValueType( result, UniqueHandle<Image, Dispatch>( image, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
2198 }
2199 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
2200 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2201
2202 // wrapper function for command vkDestroyImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyImage.html
2203 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
2204 VULKAN_HPP_INLINE void Device::destroyImage( Image image, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
2205 {
2206 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
2207 d.vkDestroyImage( static_cast<VkDevice>( m_device ), static_cast<VkImage>( image ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
2208 }
2209
2210 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2211 // wrapper function for command vkDestroyImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyImage.html
2212 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
2213 VULKAN_HPP_INLINE void Device::destroyImage( Image image, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
2214 {
2215 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
2216 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
2217 VULKAN_HPP_ASSERT( d.vkDestroyImage && "Function <vkDestroyImage> requires <VK_VERSION_1_0>" );
2218 # endif
2219
2220 d.vkDestroyImage( m_device, static_cast<VkImage>( image ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
2221 }
2222 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2223
2224 // wrapper function for command vkDestroyImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyImage.html
2225 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
2226 VULKAN_HPP_INLINE void Device::destroy( Image image, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
2227 {
2228 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
2229 d.vkDestroyImage( static_cast<VkDevice>( m_device ), static_cast<VkImage>( image ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
2230 }
2231
2232 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2233 // wrapper function for command vkDestroyImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyImage.html
2234 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
2235 VULKAN_HPP_INLINE void Device::destroy( Image image, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
2236 {
2237 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
2238 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
2239 VULKAN_HPP_ASSERT( d.vkDestroyImage && "Function <vkDestroyImage> requires <VK_VERSION_1_0>" );
2240 # endif
2241
2242 d.vkDestroyImage( m_device, static_cast<VkImage>( image ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
2243 }
2244 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2245
2246 // wrapper function for command vkGetImageSubresourceLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout.html
2247 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
2248 VULKAN_HPP_INLINE void Device::getImageSubresourceLayout( Image image,
2249 const ImageSubresource * pSubresource,
2250 SubresourceLayout * pLayout,
2251 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
2252 {
2253 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
2254 d.vkGetImageSubresourceLayout( static_cast<VkDevice>( m_device ),
2255 static_cast<VkImage>( image ),
2256 reinterpret_cast<const VkImageSubresource *>( pSubresource ),
2257 reinterpret_cast<VkSubresourceLayout *>( pLayout ) );
2258 }
2259
2260 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2261 // wrapper function for command vkGetImageSubresourceLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout.html
2262 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
2263 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE SubresourceLayout Device::getImageSubresourceLayout( Image image,
2264 const ImageSubresource & subresource,
2265 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
2266 {
2267 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
2268 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
2269 VULKAN_HPP_ASSERT( d.vkGetImageSubresourceLayout && "Function <vkGetImageSubresourceLayout> requires <VK_VERSION_1_0>" );
2270 # endif
2271
2272 SubresourceLayout layout;
2273 d.vkGetImageSubresourceLayout( m_device,
2274 static_cast<VkImage>( image ),
2275 reinterpret_cast<const VkImageSubresource *>( &subresource ),
2276 reinterpret_cast<VkSubresourceLayout *>( &layout ) );
2277
2278 return layout;
2279 }
2280 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2281
2282 // wrapper function for command vkCreateImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImageView.html
2283 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
2284 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createImageView( const ImageViewCreateInfo * pCreateInfo,
2285 const AllocationCallbacks * pAllocator,
2286 ImageView * pView,
2287 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
2288 {
2289 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
2290 return static_cast<Result>( d.vkCreateImageView( static_cast<VkDevice>( m_device ),
2291 reinterpret_cast<const VkImageViewCreateInfo *>( pCreateInfo ),
2292 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
2293 reinterpret_cast<VkImageView *>( pView ) ) );
2294 }
2295
2296 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2297 // wrapper function for command vkCreateImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImageView.html
2298 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
2299 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<ImageView>::type
2300 Device::createImageView( const ImageViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
2301 {
2302 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
2303 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
2304 VULKAN_HPP_ASSERT( d.vkCreateImageView && "Function <vkCreateImageView> requires <VK_VERSION_1_0>" );
2305 # endif
2306
2307 ImageView view;
2308 Result result = static_cast<Result>( d.vkCreateImageView( m_device,
2309 reinterpret_cast<const VkImageViewCreateInfo *>( &createInfo ),
2310 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
2311 reinterpret_cast<VkImageView *>( &view ) ) );
2312 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createImageView" );
2313
2314 return detail::createResultValueType( result, std::move( view ) );
2315 }
2316
2317 # ifndef VULKAN_HPP_NO_SMART_HANDLE
2318 // wrapper function for command vkCreateImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImageView.html
2319 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
2320 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<ImageView, Dispatch>>::type
2321 Device::createImageViewUnique( const ImageViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
2322 {
2323 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
2324 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
2325 VULKAN_HPP_ASSERT( d.vkCreateImageView && "Function <vkCreateImageView> requires <VK_VERSION_1_0>" );
2326 # endif
2327
2328 ImageView view;
2329 Result result = static_cast<Result>( d.vkCreateImageView( m_device,
2330 reinterpret_cast<const VkImageViewCreateInfo *>( &createInfo ),
2331 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
2332 reinterpret_cast<VkImageView *>( &view ) ) );
2333 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createImageViewUnique" );
2334
2335 return detail::createResultValueType( result, UniqueHandle<ImageView, Dispatch>( view, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
2336 }
2337 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
2338 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2339
2340 // wrapper function for command vkDestroyImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyImageView.html
2341 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
2342 VULKAN_HPP_INLINE void Device::destroyImageView( ImageView imageView, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
2343 {
2344 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
2345 d.vkDestroyImageView(
2346 static_cast<VkDevice>( m_device ), static_cast<VkImageView>( imageView ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
2347 }
2348
2349 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2350 // wrapper function for command vkDestroyImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyImageView.html
2351 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
2352 VULKAN_HPP_INLINE void
2353 Device::destroyImageView( ImageView imageView, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
2354 {
2355 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
2356 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
2357 VULKAN_HPP_ASSERT( d.vkDestroyImageView && "Function <vkDestroyImageView> requires <VK_VERSION_1_0>" );
2358 # endif
2359
2360 d.vkDestroyImageView( m_device, static_cast<VkImageView>( imageView ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
2361 }
2362 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2363
2364 // wrapper function for command vkDestroyImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyImageView.html
2365 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
2366 VULKAN_HPP_INLINE void Device::destroy( ImageView imageView, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
2367 {
2368 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
2369 d.vkDestroyImageView(
2370 static_cast<VkDevice>( m_device ), static_cast<VkImageView>( imageView ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
2371 }
2372
2373 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2374 // wrapper function for command vkDestroyImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyImageView.html
2375 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
2376 VULKAN_HPP_INLINE void Device::destroy( ImageView imageView, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
2377 {
2378 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
2379 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
2380 VULKAN_HPP_ASSERT( d.vkDestroyImageView && "Function <vkDestroyImageView> requires <VK_VERSION_1_0>" );
2381 # endif
2382
2383 d.vkDestroyImageView( m_device, static_cast<VkImageView>( imageView ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
2384 }
2385 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2386
2387 // wrapper function for command vkCreateCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCommandPool.html
2388 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
2389 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createCommandPool( const CommandPoolCreateInfo * pCreateInfo,
2390 const AllocationCallbacks * pAllocator,
2391 CommandPool * pCommandPool,
2392 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
2393 {
2394 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
2395 return static_cast<Result>( d.vkCreateCommandPool( static_cast<VkDevice>( m_device ),
2396 reinterpret_cast<const VkCommandPoolCreateInfo *>( pCreateInfo ),
2397 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
2398 reinterpret_cast<VkCommandPool *>( pCommandPool ) ) );
2399 }
2400
2401 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2402 // wrapper function for command vkCreateCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCommandPool.html
2403 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
2404 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<CommandPool>::type
2405 Device::createCommandPool( const CommandPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
2406 {
2407 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
2408 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
2409 VULKAN_HPP_ASSERT( d.vkCreateCommandPool && "Function <vkCreateCommandPool> requires <VK_VERSION_1_0>" );
2410 # endif
2411
2412 CommandPool commandPool;
2413 Result result = static_cast<Result>( d.vkCreateCommandPool( m_device,
2414 reinterpret_cast<const VkCommandPoolCreateInfo *>( &createInfo ),
2415 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
2416 reinterpret_cast<VkCommandPool *>( &commandPool ) ) );
2417 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createCommandPool" );
2418
2419 return detail::createResultValueType( result, std::move( commandPool ) );
2420 }
2421
2422 # ifndef VULKAN_HPP_NO_SMART_HANDLE
2423 // wrapper function for command vkCreateCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCommandPool.html
2424 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
2425 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<CommandPool, Dispatch>>::type
2426 Device::createCommandPoolUnique( const CommandPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
2427 {
2428 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
2429 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
2430 VULKAN_HPP_ASSERT( d.vkCreateCommandPool && "Function <vkCreateCommandPool> requires <VK_VERSION_1_0>" );
2431 # endif
2432
2433 CommandPool commandPool;
2434 Result result = static_cast<Result>( d.vkCreateCommandPool( m_device,
2435 reinterpret_cast<const VkCommandPoolCreateInfo *>( &createInfo ),
2436 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
2437 reinterpret_cast<VkCommandPool *>( &commandPool ) ) );
2438 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createCommandPoolUnique" );
2439
2440 return detail::createResultValueType( result,
2441 UniqueHandle<CommandPool, Dispatch>( commandPool, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
2442 }
2443 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
2444 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2445
2446 // wrapper function for command vkDestroyCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCommandPool.html
2447 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
2448 VULKAN_HPP_INLINE void
2449 Device::destroyCommandPool( CommandPool commandPool, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
2450 {
2451 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
2452 d.vkDestroyCommandPool(
2453 static_cast<VkDevice>( m_device ), static_cast<VkCommandPool>( commandPool ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
2454 }
2455
2456 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2457 // wrapper function for command vkDestroyCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCommandPool.html
2458 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
2459 VULKAN_HPP_INLINE void
2460 Device::destroyCommandPool( CommandPool commandPool, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
2461 {
2462 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
2463 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
2464 VULKAN_HPP_ASSERT( d.vkDestroyCommandPool && "Function <vkDestroyCommandPool> requires <VK_VERSION_1_0>" );
2465 # endif
2466
2467 d.vkDestroyCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
2468 }
2469 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2470
2471 // wrapper function for command vkDestroyCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCommandPool.html
2472 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
2473 VULKAN_HPP_INLINE void Device::destroy( CommandPool commandPool, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
2474 {
2475 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
2476 d.vkDestroyCommandPool(
2477 static_cast<VkDevice>( m_device ), static_cast<VkCommandPool>( commandPool ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
2478 }
2479
2480 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2481 // wrapper function for command vkDestroyCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCommandPool.html
2482 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
2483 VULKAN_HPP_INLINE void Device::destroy( CommandPool commandPool, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
2484 {
2485 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
2486 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
2487 VULKAN_HPP_ASSERT( d.vkDestroyCommandPool && "Function <vkDestroyCommandPool> requires <VK_VERSION_1_0>" );
2488 # endif
2489
2490 d.vkDestroyCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
2491 }
2492 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2493
2494 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
2495 // wrapper function for command vkResetCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetCommandPool.html
2496 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
2497 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::resetCommandPool( CommandPool commandPool,
2498 CommandPoolResetFlags flags,
2499 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
2500 {
2501 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
2502 return static_cast<Result>(
2503 d.vkResetCommandPool( static_cast<VkDevice>( m_device ), static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolResetFlags>( flags ) ) );
2504 }
2505 #else
2506 // wrapper function for command vkResetCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetCommandPool.html
2507 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
2508 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
2509 Device::resetCommandPool( CommandPool commandPool, CommandPoolResetFlags flags, Dispatch const & d ) const
2510 {
2511 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
2512 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
2513 VULKAN_HPP_ASSERT( d.vkResetCommandPool && "Function <vkResetCommandPool> requires <VK_VERSION_1_0>" );
2514 # endif
2515
2516 Result result =
2517 static_cast<Result>( d.vkResetCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolResetFlags>( flags ) ) );
2518 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::resetCommandPool" );
2519
2520 return detail::createResultValueType( result );
2521 }
2522 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
2523
2524 // wrapper function for command vkAllocateCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateCommandBuffers.html
2525 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
2526 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::allocateCommandBuffers( const CommandBufferAllocateInfo * pAllocateInfo,
2527 CommandBuffer * pCommandBuffers,
2528 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
2529 {
2530 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
2531 return static_cast<Result>( d.vkAllocateCommandBuffers( static_cast<VkDevice>( m_device ),
2532 reinterpret_cast<const VkCommandBufferAllocateInfo *>( pAllocateInfo ),
2533 reinterpret_cast<VkCommandBuffer *>( pCommandBuffers ) ) );
2534 }
2535
2536 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2537 // wrapper function for command vkAllocateCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateCommandBuffers.html
2538 template <typename CommandBufferAllocator,
2539 typename Dispatch,
2540 typename std::enable_if<std::is_same<typename CommandBufferAllocator::value_type, CommandBuffer>::value, int>::type,
2541 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
2542 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<CommandBuffer, CommandBufferAllocator>>::type
2543 Device::allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo, Dispatch const & d ) const
2544 {
2545 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
2546 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
2547 VULKAN_HPP_ASSERT( d.vkAllocateCommandBuffers && "Function <vkAllocateCommandBuffers> requires <VK_VERSION_1_0>" );
2548 # endif
2549
2550 std::vector<CommandBuffer, CommandBufferAllocator> commandBuffers( allocateInfo.commandBufferCount );
2551 Result result = static_cast<Result>( d.vkAllocateCommandBuffers(
2552 m_device, reinterpret_cast<const VkCommandBufferAllocateInfo *>( &allocateInfo ), reinterpret_cast<VkCommandBuffer *>( commandBuffers.data() ) ) );
2553 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffers" );
2554
2555 return detail::createResultValueType( result, std::move( commandBuffers ) );
2556 }
2557
2558 // wrapper function for command vkAllocateCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateCommandBuffers.html
2559 template <typename CommandBufferAllocator,
2560 typename Dispatch,
2561 typename std::enable_if<std::is_same<typename CommandBufferAllocator::value_type, CommandBuffer>::value, int>::type,
2562 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
2563 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<CommandBuffer, CommandBufferAllocator>>::type
2564 Device::allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo, CommandBufferAllocator & commandBufferAllocator, Dispatch const & d ) const
2565 {
2566 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
2567 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
2568 VULKAN_HPP_ASSERT( d.vkAllocateCommandBuffers && "Function <vkAllocateCommandBuffers> requires <VK_VERSION_1_0>" );
2569 # endif
2570
2571 std::vector<CommandBuffer, CommandBufferAllocator> commandBuffers( allocateInfo.commandBufferCount, commandBufferAllocator );
2572 Result result = static_cast<Result>( d.vkAllocateCommandBuffers(
2573 m_device, reinterpret_cast<const VkCommandBufferAllocateInfo *>( &allocateInfo ), reinterpret_cast<VkCommandBuffer *>( commandBuffers.data() ) ) );
2574 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffers" );
2575
2576 return detail::createResultValueType( result, std::move( commandBuffers ) );
2577 }
2578
2579 # ifndef VULKAN_HPP_NO_SMART_HANDLE
2580 // wrapper function for command vkAllocateCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateCommandBuffers.html
2581 template <typename Dispatch,
2582 typename CommandBufferAllocator,
2583 typename std::enable_if<std::is_same<typename CommandBufferAllocator::value_type, UniqueHandle<CommandBuffer, Dispatch>>::value, int>::type,
2584 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
2585 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<CommandBuffer, Dispatch>, CommandBufferAllocator>>::type
2586 Device::allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo, Dispatch const & d ) const
2587 {
2588 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
2589 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
2590 VULKAN_HPP_ASSERT( d.vkAllocateCommandBuffers && "Function <vkAllocateCommandBuffers> requires <VK_VERSION_1_0>" );
2591 # endif
2592
2593 std::vector<CommandBuffer> commandBuffers( allocateInfo.commandBufferCount );
2594 Result result = static_cast<Result>( d.vkAllocateCommandBuffers(
2595 m_device, reinterpret_cast<const VkCommandBufferAllocateInfo *>( &allocateInfo ), reinterpret_cast<VkCommandBuffer *>( commandBuffers.data() ) ) );
2596 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffersUnique" );
2597 std::vector<UniqueHandle<CommandBuffer, Dispatch>, CommandBufferAllocator> uniqueCommandBuffers;
2598 uniqueCommandBuffers.reserve( allocateInfo.commandBufferCount );
2599 detail::PoolFree<Device, CommandPool, Dispatch> deleter( *this, allocateInfo.commandPool, d );
2600 for ( auto const & commandBuffer : commandBuffers )
2601 {
2602 uniqueCommandBuffers.push_back( UniqueHandle<CommandBuffer, Dispatch>( commandBuffer, deleter ) );
2603 }
2604 return detail::createResultValueType( result, std::move( uniqueCommandBuffers ) );
2605 }
2606
2607 // wrapper function for command vkAllocateCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateCommandBuffers.html
2608 template <typename Dispatch,
2609 typename CommandBufferAllocator,
2610 typename std::enable_if<std::is_same<typename CommandBufferAllocator::value_type, UniqueHandle<CommandBuffer, Dispatch>>::value, int>::type,
2611 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
2612 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<CommandBuffer, Dispatch>, CommandBufferAllocator>>::type
2613 Device::allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo,
2614 CommandBufferAllocator & commandBufferAllocator,
2615 Dispatch const & d ) const
2616 {
2617 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
2618 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
2619 VULKAN_HPP_ASSERT( d.vkAllocateCommandBuffers && "Function <vkAllocateCommandBuffers> requires <VK_VERSION_1_0>" );
2620 # endif
2621
2622 std::vector<CommandBuffer> commandBuffers( allocateInfo.commandBufferCount );
2623 Result result = static_cast<Result>( d.vkAllocateCommandBuffers(
2624 m_device, reinterpret_cast<const VkCommandBufferAllocateInfo *>( &allocateInfo ), reinterpret_cast<VkCommandBuffer *>( commandBuffers.data() ) ) );
2625 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffersUnique" );
2626 std::vector<UniqueHandle<CommandBuffer, Dispatch>, CommandBufferAllocator> uniqueCommandBuffers( commandBufferAllocator );
2627 uniqueCommandBuffers.reserve( allocateInfo.commandBufferCount );
2628 detail::PoolFree<Device, CommandPool, Dispatch> deleter( *this, allocateInfo.commandPool, d );
2629 for ( auto const & commandBuffer : commandBuffers )
2630 {
2631 uniqueCommandBuffers.push_back( UniqueHandle<CommandBuffer, Dispatch>( commandBuffer, deleter ) );
2632 }
2633 return detail::createResultValueType( result, std::move( uniqueCommandBuffers ) );
2634 }
2635 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
2636 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2637
2638 // wrapper function for command vkFreeCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeCommandBuffers.html
2639 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
2640 VULKAN_HPP_INLINE void Device::freeCommandBuffers( CommandPool commandPool,
2641 uint32_t commandBufferCount,
2642 const CommandBuffer * pCommandBuffers,
2643 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
2644 {
2645 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
2646 d.vkFreeCommandBuffers( static_cast<VkDevice>( m_device ),
2647 static_cast<VkCommandPool>( commandPool ),
2648 commandBufferCount,
2649 reinterpret_cast<const VkCommandBuffer *>( pCommandBuffers ) );
2650 }
2651
2652 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2653 // wrapper function for command vkFreeCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeCommandBuffers.html
2654 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
2655 VULKAN_HPP_INLINE void
2656 Device::freeCommandBuffers( CommandPool commandPool, ArrayProxy<const CommandBuffer> const & commandBuffers, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
2657 {
2658 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
2659 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
2660 VULKAN_HPP_ASSERT( d.vkFreeCommandBuffers && "Function <vkFreeCommandBuffers> requires <VK_VERSION_1_0>" );
2661 # endif
2662
2663 d.vkFreeCommandBuffers(
2664 m_device, static_cast<VkCommandPool>( commandPool ), commandBuffers.size(), reinterpret_cast<const VkCommandBuffer *>( commandBuffers.data() ) );
2665 }
2666 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2667
2668 // wrapper function for command vkFreeCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeCommandBuffers.html
2669 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
2670 VULKAN_HPP_INLINE void( Device::free )( CommandPool commandPool,
2671 uint32_t commandBufferCount,
2672 const CommandBuffer * pCommandBuffers,
2673 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
2674 {
2675 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
2676 d.vkFreeCommandBuffers( static_cast<VkDevice>( m_device ),
2677 static_cast<VkCommandPool>( commandPool ),
2678 commandBufferCount,
2679 reinterpret_cast<const VkCommandBuffer *>( pCommandBuffers ) );
2680 }
2681
2682 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2683 // wrapper function for command vkFreeCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeCommandBuffers.html
2684 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
2685 VULKAN_HPP_INLINE void( Device::free )( CommandPool commandPool,
2686 ArrayProxy<const CommandBuffer> const & commandBuffers,
2687 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
2688 {
2689 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
2690 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
2691 VULKAN_HPP_ASSERT( d.vkFreeCommandBuffers && "Function <vkFreeCommandBuffers> requires <VK_VERSION_1_0>" );
2692 # endif
2693
2694 d.vkFreeCommandBuffers(
2695 m_device, static_cast<VkCommandPool>( commandPool ), commandBuffers.size(), reinterpret_cast<const VkCommandBuffer *>( commandBuffers.data() ) );
2696 }
2697 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2698
2699 // wrapper function for command vkBeginCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBeginCommandBuffer.html
2700 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
2701 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result CommandBuffer::begin( const CommandBufferBeginInfo * pBeginInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
2702 {
2703 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
2704 return static_cast<Result>(
2705 d.vkBeginCommandBuffer( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkCommandBufferBeginInfo *>( pBeginInfo ) ) );
2706 }
2707
2708 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2709 // wrapper function for command vkBeginCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBeginCommandBuffer.html
2710 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
2711 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type CommandBuffer::begin( const CommandBufferBeginInfo & beginInfo,
2712 Dispatch const & d ) const
2713 {
2714 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
2715 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
2716 VULKAN_HPP_ASSERT( d.vkBeginCommandBuffer && "Function <vkBeginCommandBuffer> requires <VK_VERSION_1_0>" );
2717 # endif
2718
2719 Result result = static_cast<Result>( d.vkBeginCommandBuffer( m_commandBuffer, reinterpret_cast<const VkCommandBufferBeginInfo *>( &beginInfo ) ) );
2720 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::begin" );
2721
2722 return detail::createResultValueType( result );
2723 }
2724 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2725
2726 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
2727 // wrapper function for command vkEndCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEndCommandBuffer.html
2728 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
2729 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result CommandBuffer::end( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
2730 {
2731 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
2732 return static_cast<Result>( d.vkEndCommandBuffer( static_cast<VkCommandBuffer>( m_commandBuffer ) ) );
2733 }
2734 #else
2735 // wrapper function for command vkEndCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEndCommandBuffer.html
2736 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
2737 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type CommandBuffer::end( Dispatch const & d ) const
2738 {
2739 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
2740 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
2741 VULKAN_HPP_ASSERT( d.vkEndCommandBuffer && "Function <vkEndCommandBuffer> requires <VK_VERSION_1_0>" );
2742 # endif
2743
2744 Result result = static_cast<Result>( d.vkEndCommandBuffer( m_commandBuffer ) );
2745 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::end" );
2746
2747 return detail::createResultValueType( result );
2748 }
2749 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
2750
2751 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
2752 // wrapper function for command vkResetCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetCommandBuffer.html
2753 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
2754 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result CommandBuffer::reset( CommandBufferResetFlags flags, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
2755 {
2756 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
2757 return static_cast<Result>( d.vkResetCommandBuffer( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkCommandBufferResetFlags>( flags ) ) );
2758 }
2759 #else
2760 // wrapper function for command vkResetCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetCommandBuffer.html
2761 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
2762 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type CommandBuffer::reset( CommandBufferResetFlags flags,
2763 Dispatch const & d ) const
2764 {
2765 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
2766 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
2767 VULKAN_HPP_ASSERT( d.vkResetCommandBuffer && "Function <vkResetCommandBuffer> requires <VK_VERSION_1_0>" );
2768 # endif
2769
2770 Result result = static_cast<Result>( d.vkResetCommandBuffer( m_commandBuffer, static_cast<VkCommandBufferResetFlags>( flags ) ) );
2771 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::reset" );
2772
2773 return detail::createResultValueType( result );
2774 }
2775 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
2776
2777 // wrapper function for command vkCmdCopyBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBuffer.html
2778 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
2779 VULKAN_HPP_INLINE void CommandBuffer::copyBuffer(
2780 Buffer srcBuffer, Buffer dstBuffer, uint32_t regionCount, const BufferCopy * pRegions, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
2781 {
2782 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
2783 d.vkCmdCopyBuffer( static_cast<VkCommandBuffer>( m_commandBuffer ),
2784 static_cast<VkBuffer>( srcBuffer ),
2785 static_cast<VkBuffer>( dstBuffer ),
2786 regionCount,
2787 reinterpret_cast<const VkBufferCopy *>( pRegions ) );
2788 }
2789
2790 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2791 // wrapper function for command vkCmdCopyBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBuffer.html
2792 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
2793 VULKAN_HPP_INLINE void
2794 CommandBuffer::copyBuffer( Buffer srcBuffer, Buffer dstBuffer, ArrayProxy<const BufferCopy> const & regions, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
2795 {
2796 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
2797 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
2798 VULKAN_HPP_ASSERT( d.vkCmdCopyBuffer && "Function <vkCmdCopyBuffer> requires <VK_VERSION_1_0>" );
2799 # endif
2800
2801 d.vkCmdCopyBuffer( m_commandBuffer,
2802 static_cast<VkBuffer>( srcBuffer ),
2803 static_cast<VkBuffer>( dstBuffer ),
2804 regions.size(),
2805 reinterpret_cast<const VkBufferCopy *>( regions.data() ) );
2806 }
2807 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2808
2809 // wrapper function for command vkCmdCopyImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImage.html
2810 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
2811 VULKAN_HPP_INLINE void CommandBuffer::copyImage( Image srcImage,
2812 ImageLayout srcImageLayout,
2813 Image dstImage,
2814 ImageLayout dstImageLayout,
2815 uint32_t regionCount,
2816 const ImageCopy * pRegions,
2817 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
2818 {
2819 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
2820 d.vkCmdCopyImage( static_cast<VkCommandBuffer>( m_commandBuffer ),
2821 static_cast<VkImage>( srcImage ),
2822 static_cast<VkImageLayout>( srcImageLayout ),
2823 static_cast<VkImage>( dstImage ),
2824 static_cast<VkImageLayout>( dstImageLayout ),
2825 regionCount,
2826 reinterpret_cast<const VkImageCopy *>( pRegions ) );
2827 }
2828
2829 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2830 // wrapper function for command vkCmdCopyImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImage.html
2831 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
2832 VULKAN_HPP_INLINE void CommandBuffer::copyImage( Image srcImage,
2833 ImageLayout srcImageLayout,
2834 Image dstImage,
2835 ImageLayout dstImageLayout,
2836 ArrayProxy<const ImageCopy> const & regions,
2837 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
2838 {
2839 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
2840 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
2841 VULKAN_HPP_ASSERT( d.vkCmdCopyImage && "Function <vkCmdCopyImage> requires <VK_VERSION_1_0>" );
2842 # endif
2843
2844 d.vkCmdCopyImage( m_commandBuffer,
2845 static_cast<VkImage>( srcImage ),
2846 static_cast<VkImageLayout>( srcImageLayout ),
2847 static_cast<VkImage>( dstImage ),
2848 static_cast<VkImageLayout>( dstImageLayout ),
2849 regions.size(),
2850 reinterpret_cast<const VkImageCopy *>( regions.data() ) );
2851 }
2852 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2853
2854 // wrapper function for command vkCmdCopyBufferToImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBufferToImage.html
2855 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
2856 VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage( Buffer srcBuffer,
2857 Image dstImage,
2858 ImageLayout dstImageLayout,
2859 uint32_t regionCount,
2860 const BufferImageCopy * pRegions,
2861 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
2862 {
2863 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
2864 d.vkCmdCopyBufferToImage( static_cast<VkCommandBuffer>( m_commandBuffer ),
2865 static_cast<VkBuffer>( srcBuffer ),
2866 static_cast<VkImage>( dstImage ),
2867 static_cast<VkImageLayout>( dstImageLayout ),
2868 regionCount,
2869 reinterpret_cast<const VkBufferImageCopy *>( pRegions ) );
2870 }
2871
2872 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2873 // wrapper function for command vkCmdCopyBufferToImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBufferToImage.html
2874 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
2875 VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage( Buffer srcBuffer,
2876 Image dstImage,
2877 ImageLayout dstImageLayout,
2878 ArrayProxy<const BufferImageCopy> const & regions,
2879 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
2880 {
2881 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
2882 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
2883 VULKAN_HPP_ASSERT( d.vkCmdCopyBufferToImage && "Function <vkCmdCopyBufferToImage> requires <VK_VERSION_1_0>" );
2884 # endif
2885
2886 d.vkCmdCopyBufferToImage( m_commandBuffer,
2887 static_cast<VkBuffer>( srcBuffer ),
2888 static_cast<VkImage>( dstImage ),
2889 static_cast<VkImageLayout>( dstImageLayout ),
2890 regions.size(),
2891 reinterpret_cast<const VkBufferImageCopy *>( regions.data() ) );
2892 }
2893 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2894
2895 // wrapper function for command vkCmdCopyImageToBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToBuffer.html
2896 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
2897 VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer( Image srcImage,
2898 ImageLayout srcImageLayout,
2899 Buffer dstBuffer,
2900 uint32_t regionCount,
2901 const BufferImageCopy * pRegions,
2902 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
2903 {
2904 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
2905 d.vkCmdCopyImageToBuffer( static_cast<VkCommandBuffer>( m_commandBuffer ),
2906 static_cast<VkImage>( srcImage ),
2907 static_cast<VkImageLayout>( srcImageLayout ),
2908 static_cast<VkBuffer>( dstBuffer ),
2909 regionCount,
2910 reinterpret_cast<const VkBufferImageCopy *>( pRegions ) );
2911 }
2912
2913 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2914 // wrapper function for command vkCmdCopyImageToBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToBuffer.html
2915 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
2916 VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer( Image srcImage,
2917 ImageLayout srcImageLayout,
2918 Buffer dstBuffer,
2919 ArrayProxy<const BufferImageCopy> const & regions,
2920 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
2921 {
2922 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
2923 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
2924 VULKAN_HPP_ASSERT( d.vkCmdCopyImageToBuffer && "Function <vkCmdCopyImageToBuffer> requires <VK_VERSION_1_0>" );
2925 # endif
2926
2927 d.vkCmdCopyImageToBuffer( m_commandBuffer,
2928 static_cast<VkImage>( srcImage ),
2929 static_cast<VkImageLayout>( srcImageLayout ),
2930 static_cast<VkBuffer>( dstBuffer ),
2931 regions.size(),
2932 reinterpret_cast<const VkBufferImageCopy *>( regions.data() ) );
2933 }
2934 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2935
2936 // wrapper function for command vkCmdUpdateBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdUpdateBuffer.html
2937 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
2938 VULKAN_HPP_INLINE void
2939 CommandBuffer::updateBuffer( Buffer dstBuffer, DeviceSize dstOffset, DeviceSize dataSize, const void * pData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
2940 {
2941 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
2942 d.vkCmdUpdateBuffer( static_cast<VkCommandBuffer>( m_commandBuffer ),
2943 static_cast<VkBuffer>( dstBuffer ),
2944 static_cast<VkDeviceSize>( dstOffset ),
2945 static_cast<VkDeviceSize>( dataSize ),
2946 pData );
2947 }
2948
2949 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2950 // wrapper function for command vkCmdUpdateBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdUpdateBuffer.html
2951 template <typename DataType, typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
2952 VULKAN_HPP_INLINE void
2953 CommandBuffer::updateBuffer( Buffer dstBuffer, DeviceSize dstOffset, ArrayProxy<const DataType> const & data, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
2954 {
2955 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
2956 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
2957 VULKAN_HPP_ASSERT( d.vkCmdUpdateBuffer && "Function <vkCmdUpdateBuffer> requires <VK_VERSION_1_0>" );
2958 # endif
2959
2960 d.vkCmdUpdateBuffer( m_commandBuffer,
2961 static_cast<VkBuffer>( dstBuffer ),
2962 static_cast<VkDeviceSize>( dstOffset ),
2963 data.size() * sizeof( DataType ),
2964 reinterpret_cast<const void *>( data.data() ) );
2965 }
2966 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2967
2968 // wrapper function for command vkCmdFillBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdFillBuffer.html
2969 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
2970 VULKAN_HPP_INLINE void
2971 CommandBuffer::fillBuffer( Buffer dstBuffer, DeviceSize dstOffset, DeviceSize size, uint32_t data, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
2972 {
2973 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
2974 d.vkCmdFillBuffer( static_cast<VkCommandBuffer>( m_commandBuffer ),
2975 static_cast<VkBuffer>( dstBuffer ),
2976 static_cast<VkDeviceSize>( dstOffset ),
2977 static_cast<VkDeviceSize>( size ),
2978 data );
2979 }
2980
2981 // wrapper function for command vkCmdPipelineBarrier, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPipelineBarrier.html
2982 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
2983 VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier( PipelineStageFlags srcStageMask,
2984 PipelineStageFlags dstStageMask,
2985 DependencyFlags dependencyFlags,
2986 uint32_t memoryBarrierCount,
2987 const MemoryBarrier * pMemoryBarriers,
2988 uint32_t bufferMemoryBarrierCount,
2989 const BufferMemoryBarrier * pBufferMemoryBarriers,
2990 uint32_t imageMemoryBarrierCount,
2991 const ImageMemoryBarrier * pImageMemoryBarriers,
2992 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
2993 {
2994 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
2995 d.vkCmdPipelineBarrier( static_cast<VkCommandBuffer>( m_commandBuffer ),
2996 static_cast<VkPipelineStageFlags>( srcStageMask ),
2997 static_cast<VkPipelineStageFlags>( dstStageMask ),
2998 static_cast<VkDependencyFlags>( dependencyFlags ),
2999 memoryBarrierCount,
3000 reinterpret_cast<const VkMemoryBarrier *>( pMemoryBarriers ),
3001 bufferMemoryBarrierCount,
3002 reinterpret_cast<const VkBufferMemoryBarrier *>( pBufferMemoryBarriers ),
3003 imageMemoryBarrierCount,
3004 reinterpret_cast<const VkImageMemoryBarrier *>( pImageMemoryBarriers ) );
3005 }
3006
3007 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3008 // wrapper function for command vkCmdPipelineBarrier, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPipelineBarrier.html
3009 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
3010 VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier( PipelineStageFlags srcStageMask,
3011 PipelineStageFlags dstStageMask,
3012 DependencyFlags dependencyFlags,
3013 ArrayProxy<const MemoryBarrier> const & memoryBarriers,
3014 ArrayProxy<const BufferMemoryBarrier> const & bufferMemoryBarriers,
3015 ArrayProxy<const ImageMemoryBarrier> const & imageMemoryBarriers,
3016 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
3017 {
3018 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
3019 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
3020 VULKAN_HPP_ASSERT( d.vkCmdPipelineBarrier && "Function <vkCmdPipelineBarrier> requires <VK_VERSION_1_0>" );
3021 # endif
3022
3023 d.vkCmdPipelineBarrier( m_commandBuffer,
3024 static_cast<VkPipelineStageFlags>( srcStageMask ),
3025 static_cast<VkPipelineStageFlags>( dstStageMask ),
3026 static_cast<VkDependencyFlags>( dependencyFlags ),
3027 memoryBarriers.size(),
3028 reinterpret_cast<const VkMemoryBarrier *>( memoryBarriers.data() ),
3029 bufferMemoryBarriers.size(),
3030 reinterpret_cast<const VkBufferMemoryBarrier *>( bufferMemoryBarriers.data() ),
3031 imageMemoryBarriers.size(),
3032 reinterpret_cast<const VkImageMemoryBarrier *>( imageMemoryBarriers.data() ) );
3033 }
3034 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3035
3036 // wrapper function for command vkCmdBeginQuery, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginQuery.html
3037 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
3038 VULKAN_HPP_INLINE void CommandBuffer::beginQuery( QueryPool queryPool, uint32_t query, QueryControlFlags flags, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
3039 {
3040 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
3041 d.vkCmdBeginQuery(
3042 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkQueryPool>( queryPool ), query, static_cast<VkQueryControlFlags>( flags ) );
3043 }
3044
3045 // wrapper function for command vkCmdEndQuery, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndQuery.html
3046 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
3047 VULKAN_HPP_INLINE void CommandBuffer::endQuery( QueryPool queryPool, uint32_t query, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
3048 {
3049 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
3050 d.vkCmdEndQuery( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkQueryPool>( queryPool ), query );
3051 }
3052
3053 // wrapper function for command vkCmdResetQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResetQueryPool.html
3054 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
3055 VULKAN_HPP_INLINE void
3056 CommandBuffer::resetQueryPool( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
3057 {
3058 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
3059 d.vkCmdResetQueryPool( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount );
3060 }
3061
3062 // wrapper function for command vkCmdWriteTimestamp, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteTimestamp.html
3063 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
3064 VULKAN_HPP_INLINE void
3065 CommandBuffer::writeTimestamp( PipelineStageFlagBits pipelineStage, QueryPool queryPool, uint32_t query, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
3066 {
3067 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
3068 d.vkCmdWriteTimestamp(
3069 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkPipelineStageFlagBits>( pipelineStage ), static_cast<VkQueryPool>( queryPool ), query );
3070 }
3071
3072 // wrapper function for command vkCmdCopyQueryPoolResults, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyQueryPoolResults.html
3073 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
3074 VULKAN_HPP_INLINE void CommandBuffer::copyQueryPoolResults( QueryPool queryPool,
3075 uint32_t firstQuery,
3076 uint32_t queryCount,
3077 Buffer dstBuffer,
3078 DeviceSize dstOffset,
3079 DeviceSize stride,
3080 QueryResultFlags flags,
3081 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
3082 {
3083 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
3084 d.vkCmdCopyQueryPoolResults( static_cast<VkCommandBuffer>( m_commandBuffer ),
3085 static_cast<VkQueryPool>( queryPool ),
3086 firstQuery,
3087 queryCount,
3088 static_cast<VkBuffer>( dstBuffer ),
3089 static_cast<VkDeviceSize>( dstOffset ),
3090 static_cast<VkDeviceSize>( stride ),
3091 static_cast<VkQueryResultFlags>( flags ) );
3092 }
3093
3094 // wrapper function for command vkCmdExecuteCommands, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdExecuteCommands.html
3095 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
3096 VULKAN_HPP_INLINE void
3097 CommandBuffer::executeCommands( uint32_t commandBufferCount, const CommandBuffer * pCommandBuffers, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
3098 {
3099 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
3100 d.vkCmdExecuteCommands( static_cast<VkCommandBuffer>( m_commandBuffer ), commandBufferCount, reinterpret_cast<const VkCommandBuffer *>( pCommandBuffers ) );
3101 }
3102
3103 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3104 // wrapper function for command vkCmdExecuteCommands, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdExecuteCommands.html
3105 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
3106 VULKAN_HPP_INLINE void CommandBuffer::executeCommands( ArrayProxy<const CommandBuffer> const & commandBuffers, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
3107 {
3108 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
3109 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
3110 VULKAN_HPP_ASSERT( d.vkCmdExecuteCommands && "Function <vkCmdExecuteCommands> requires <VK_VERSION_1_0>" );
3111 # endif
3112
3113 d.vkCmdExecuteCommands( m_commandBuffer, commandBuffers.size(), reinterpret_cast<const VkCommandBuffer *>( commandBuffers.data() ) );
3114 }
3115 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3116
3117 // wrapper function for command vkCreateEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateEvent.html
3118 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
3119 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createEvent( const EventCreateInfo * pCreateInfo,
3120 const AllocationCallbacks * pAllocator,
3121 Event * pEvent,
3122 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
3123 {
3124 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
3125 return static_cast<Result>( d.vkCreateEvent( static_cast<VkDevice>( m_device ),
3126 reinterpret_cast<const VkEventCreateInfo *>( pCreateInfo ),
3127 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
3128 reinterpret_cast<VkEvent *>( pEvent ) ) );
3129 }
3130
3131 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3132 // wrapper function for command vkCreateEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateEvent.html
3133 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
3134 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<Event>::type
3135 Device::createEvent( const EventCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
3136 {
3137 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
3138 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
3139 VULKAN_HPP_ASSERT( d.vkCreateEvent && "Function <vkCreateEvent> requires <VK_VERSION_1_0>" );
3140 # endif
3141
3142 Event event;
3143 Result result = static_cast<Result>( d.vkCreateEvent( m_device,
3144 reinterpret_cast<const VkEventCreateInfo *>( &createInfo ),
3145 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
3146 reinterpret_cast<VkEvent *>( &event ) ) );
3147 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createEvent" );
3148
3149 return detail::createResultValueType( result, std::move( event ) );
3150 }
3151
3152 # ifndef VULKAN_HPP_NO_SMART_HANDLE
3153 // wrapper function for command vkCreateEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateEvent.html
3154 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
3155 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Event, Dispatch>>::type
3156 Device::createEventUnique( const EventCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
3157 {
3158 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
3159 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
3160 VULKAN_HPP_ASSERT( d.vkCreateEvent && "Function <vkCreateEvent> requires <VK_VERSION_1_0>" );
3161 # endif
3162
3163 Event event;
3164 Result result = static_cast<Result>( d.vkCreateEvent( m_device,
3165 reinterpret_cast<const VkEventCreateInfo *>( &createInfo ),
3166 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
3167 reinterpret_cast<VkEvent *>( &event ) ) );
3168 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createEventUnique" );
3169
3170 return detail::createResultValueType( result, UniqueHandle<Event, Dispatch>( event, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
3171 }
3172 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
3173 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3174
3175 // wrapper function for command vkDestroyEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyEvent.html
3176 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
3177 VULKAN_HPP_INLINE void Device::destroyEvent( Event event, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
3178 {
3179 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
3180 d.vkDestroyEvent( static_cast<VkDevice>( m_device ), static_cast<VkEvent>( event ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
3181 }
3182
3183 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3184 // wrapper function for command vkDestroyEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyEvent.html
3185 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
3186 VULKAN_HPP_INLINE void Device::destroyEvent( Event event, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
3187 {
3188 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
3189 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
3190 VULKAN_HPP_ASSERT( d.vkDestroyEvent && "Function <vkDestroyEvent> requires <VK_VERSION_1_0>" );
3191 # endif
3192
3193 d.vkDestroyEvent( m_device, static_cast<VkEvent>( event ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
3194 }
3195 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3196
3197 // wrapper function for command vkDestroyEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyEvent.html
3198 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
3199 VULKAN_HPP_INLINE void Device::destroy( Event event, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
3200 {
3201 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
3202 d.vkDestroyEvent( static_cast<VkDevice>( m_device ), static_cast<VkEvent>( event ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
3203 }
3204
3205 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3206 // wrapper function for command vkDestroyEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyEvent.html
3207 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
3208 VULKAN_HPP_INLINE void Device::destroy( Event event, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
3209 {
3210 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
3211 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
3212 VULKAN_HPP_ASSERT( d.vkDestroyEvent && "Function <vkDestroyEvent> requires <VK_VERSION_1_0>" );
3213 # endif
3214
3215 d.vkDestroyEvent( m_device, static_cast<VkEvent>( event ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
3216 }
3217 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3218
3219 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
3220 // wrapper function for command vkGetEventStatus, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEventStatus.html
3221 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
3222 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getEventStatus( Event event, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
3223 {
3224 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
3225 return static_cast<Result>( d.vkGetEventStatus( static_cast<VkDevice>( m_device ), static_cast<VkEvent>( event ) ) );
3226 }
3227 #else
3228 // wrapper function for command vkGetEventStatus, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEventStatus.html
3229 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
3230 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getEventStatus( Event event, Dispatch const & d ) const
3231 {
3232 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
3233 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
3234 VULKAN_HPP_ASSERT( d.vkGetEventStatus && "Function <vkGetEventStatus> requires <VK_VERSION_1_0>" );
3235 # endif
3236
3237 Result result = static_cast<Result>( d.vkGetEventStatus( m_device, static_cast<VkEvent>( event ) ) );
3238 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getEventStatus", { Result::eEventSet, Result::eEventReset } );
3239
3240 return static_cast<Result>( result );
3241 }
3242 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3243
3244 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
3245 // wrapper function for command vkSetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetEvent.html
3246 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
3247 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::setEvent( Event event, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
3248 {
3249 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
3250 return static_cast<Result>( d.vkSetEvent( static_cast<VkDevice>( m_device ), static_cast<VkEvent>( event ) ) );
3251 }
3252 #else
3253 // wrapper function for command vkSetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetEvent.html
3254 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
3255 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::setEvent( Event event, Dispatch const & d ) const
3256 {
3257 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
3258 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
3259 VULKAN_HPP_ASSERT( d.vkSetEvent && "Function <vkSetEvent> requires <VK_VERSION_1_0>" );
3260 # endif
3261
3262 Result result = static_cast<Result>( d.vkSetEvent( m_device, static_cast<VkEvent>( event ) ) );
3263 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setEvent" );
3264
3265 return detail::createResultValueType( result );
3266 }
3267 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3268
3269 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
3270 // wrapper function for command vkResetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetEvent.html
3271 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
3272 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::resetEvent( Event event, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
3273 {
3274 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
3275 return static_cast<Result>( d.vkResetEvent( static_cast<VkDevice>( m_device ), static_cast<VkEvent>( event ) ) );
3276 }
3277 #else
3278 // wrapper function for command vkResetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetEvent.html
3279 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
3280 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::resetEvent( Event event, Dispatch const & d ) const
3281 {
3282 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
3283 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
3284 VULKAN_HPP_ASSERT( d.vkResetEvent && "Function <vkResetEvent> requires <VK_VERSION_1_0>" );
3285 # endif
3286
3287 Result result = static_cast<Result>( d.vkResetEvent( m_device, static_cast<VkEvent>( event ) ) );
3288 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::resetEvent" );
3289
3290 return detail::createResultValueType( result );
3291 }
3292 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3293
3294 // wrapper function for command vkCreateBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBufferView.html
3295 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
3296 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createBufferView( const BufferViewCreateInfo * pCreateInfo,
3297 const AllocationCallbacks * pAllocator,
3298 BufferView * pView,
3299 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
3300 {
3301 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
3302 return static_cast<Result>( d.vkCreateBufferView( static_cast<VkDevice>( m_device ),
3303 reinterpret_cast<const VkBufferViewCreateInfo *>( pCreateInfo ),
3304 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
3305 reinterpret_cast<VkBufferView *>( pView ) ) );
3306 }
3307
3308 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3309 // wrapper function for command vkCreateBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBufferView.html
3310 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
3311 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<BufferView>::type
3312 Device::createBufferView( const BufferViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
3313 {
3314 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
3315 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
3316 VULKAN_HPP_ASSERT( d.vkCreateBufferView && "Function <vkCreateBufferView> requires <VK_VERSION_1_0>" );
3317 # endif
3318
3319 BufferView view;
3320 Result result = static_cast<Result>( d.vkCreateBufferView( m_device,
3321 reinterpret_cast<const VkBufferViewCreateInfo *>( &createInfo ),
3322 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
3323 reinterpret_cast<VkBufferView *>( &view ) ) );
3324 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createBufferView" );
3325
3326 return detail::createResultValueType( result, std::move( view ) );
3327 }
3328
3329 # ifndef VULKAN_HPP_NO_SMART_HANDLE
3330 // wrapper function for command vkCreateBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBufferView.html
3331 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
3332 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<BufferView, Dispatch>>::type
3333 Device::createBufferViewUnique( const BufferViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
3334 {
3335 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
3336 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
3337 VULKAN_HPP_ASSERT( d.vkCreateBufferView && "Function <vkCreateBufferView> requires <VK_VERSION_1_0>" );
3338 # endif
3339
3340 BufferView view;
3341 Result result = static_cast<Result>( d.vkCreateBufferView( m_device,
3342 reinterpret_cast<const VkBufferViewCreateInfo *>( &createInfo ),
3343 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
3344 reinterpret_cast<VkBufferView *>( &view ) ) );
3345 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createBufferViewUnique" );
3346
3347 return detail::createResultValueType( result, UniqueHandle<BufferView, Dispatch>( view, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
3348 }
3349 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
3350 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3351
3352 // wrapper function for command vkDestroyBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBufferView.html
3353 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
3354 VULKAN_HPP_INLINE void
3355 Device::destroyBufferView( BufferView bufferView, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
3356 {
3357 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
3358 d.vkDestroyBufferView(
3359 static_cast<VkDevice>( m_device ), static_cast<VkBufferView>( bufferView ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
3360 }
3361
3362 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3363 // wrapper function for command vkDestroyBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBufferView.html
3364 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
3365 VULKAN_HPP_INLINE void
3366 Device::destroyBufferView( BufferView bufferView, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
3367 {
3368 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
3369 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
3370 VULKAN_HPP_ASSERT( d.vkDestroyBufferView && "Function <vkDestroyBufferView> requires <VK_VERSION_1_0>" );
3371 # endif
3372
3373 d.vkDestroyBufferView( m_device, static_cast<VkBufferView>( bufferView ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
3374 }
3375 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3376
3377 // wrapper function for command vkDestroyBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBufferView.html
3378 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
3379 VULKAN_HPP_INLINE void Device::destroy( BufferView bufferView, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
3380 {
3381 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
3382 d.vkDestroyBufferView(
3383 static_cast<VkDevice>( m_device ), static_cast<VkBufferView>( bufferView ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
3384 }
3385
3386 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3387 // wrapper function for command vkDestroyBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBufferView.html
3388 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
3389 VULKAN_HPP_INLINE void Device::destroy( BufferView bufferView, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
3390 {
3391 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
3392 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
3393 VULKAN_HPP_ASSERT( d.vkDestroyBufferView && "Function <vkDestroyBufferView> requires <VK_VERSION_1_0>" );
3394 # endif
3395
3396 d.vkDestroyBufferView( m_device, static_cast<VkBufferView>( bufferView ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
3397 }
3398 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3399
3400 // wrapper function for command vkCreateShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShaderModule.html
3401 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
3402 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createShaderModule( const ShaderModuleCreateInfo * pCreateInfo,
3403 const AllocationCallbacks * pAllocator,
3404 ShaderModule * pShaderModule,
3405 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
3406 {
3407 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
3408 return static_cast<Result>( d.vkCreateShaderModule( static_cast<VkDevice>( m_device ),
3409 reinterpret_cast<const VkShaderModuleCreateInfo *>( pCreateInfo ),
3410 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
3411 reinterpret_cast<VkShaderModule *>( pShaderModule ) ) );
3412 }
3413
3414 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3415 // wrapper function for command vkCreateShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShaderModule.html
3416 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
3417 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<ShaderModule>::type
3418 Device::createShaderModule( const ShaderModuleCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
3419 {
3420 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
3421 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
3422 VULKAN_HPP_ASSERT( d.vkCreateShaderModule && "Function <vkCreateShaderModule> requires <VK_VERSION_1_0>" );
3423 # endif
3424
3425 ShaderModule shaderModule;
3426 Result result = static_cast<Result>( d.vkCreateShaderModule( m_device,
3427 reinterpret_cast<const VkShaderModuleCreateInfo *>( &createInfo ),
3428 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
3429 reinterpret_cast<VkShaderModule *>( &shaderModule ) ) );
3430 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createShaderModule" );
3431
3432 return detail::createResultValueType( result, std::move( shaderModule ) );
3433 }
3434
3435 # ifndef VULKAN_HPP_NO_SMART_HANDLE
3436 // wrapper function for command vkCreateShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShaderModule.html
3437 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
3438 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<ShaderModule, Dispatch>>::type
3439 Device::createShaderModuleUnique( const ShaderModuleCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
3440 {
3441 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
3442 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
3443 VULKAN_HPP_ASSERT( d.vkCreateShaderModule && "Function <vkCreateShaderModule> requires <VK_VERSION_1_0>" );
3444 # endif
3445
3446 ShaderModule shaderModule;
3447 Result result = static_cast<Result>( d.vkCreateShaderModule( m_device,
3448 reinterpret_cast<const VkShaderModuleCreateInfo *>( &createInfo ),
3449 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
3450 reinterpret_cast<VkShaderModule *>( &shaderModule ) ) );
3451 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createShaderModuleUnique" );
3452
3453 return detail::createResultValueType(
3454 result, UniqueHandle<ShaderModule, Dispatch>( shaderModule, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
3455 }
3456 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
3457 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3458
3459 // wrapper function for command vkDestroyShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyShaderModule.html
3460 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
3461 VULKAN_HPP_INLINE void
3462 Device::destroyShaderModule( ShaderModule shaderModule, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
3463 {
3464 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
3465 d.vkDestroyShaderModule(
3466 static_cast<VkDevice>( m_device ), static_cast<VkShaderModule>( shaderModule ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
3467 }
3468
3469 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3470 // wrapper function for command vkDestroyShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyShaderModule.html
3471 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
3472 VULKAN_HPP_INLINE void
3473 Device::destroyShaderModule( ShaderModule shaderModule, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
3474 {
3475 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
3476 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
3477 VULKAN_HPP_ASSERT( d.vkDestroyShaderModule && "Function <vkDestroyShaderModule> requires <VK_VERSION_1_0>" );
3478 # endif
3479
3480 d.vkDestroyShaderModule( m_device, static_cast<VkShaderModule>( shaderModule ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
3481 }
3482 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3483
3484 // wrapper function for command vkDestroyShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyShaderModule.html
3485 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
3486 VULKAN_HPP_INLINE void Device::destroy( ShaderModule shaderModule, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
3487 {
3488 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
3489 d.vkDestroyShaderModule(
3490 static_cast<VkDevice>( m_device ), static_cast<VkShaderModule>( shaderModule ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
3491 }
3492
3493 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3494 // wrapper function for command vkDestroyShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyShaderModule.html
3495 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
3496 VULKAN_HPP_INLINE void
3497 Device::destroy( ShaderModule shaderModule, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
3498 {
3499 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
3500 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
3501 VULKAN_HPP_ASSERT( d.vkDestroyShaderModule && "Function <vkDestroyShaderModule> requires <VK_VERSION_1_0>" );
3502 # endif
3503
3504 d.vkDestroyShaderModule( m_device, static_cast<VkShaderModule>( shaderModule ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
3505 }
3506 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3507
3508 // wrapper function for command vkCreatePipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineCache.html
3509 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
3510 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createPipelineCache( const PipelineCacheCreateInfo * pCreateInfo,
3511 const AllocationCallbacks * pAllocator,
3512 PipelineCache * pPipelineCache,
3513 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
3514 {
3515 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
3516 return static_cast<Result>( d.vkCreatePipelineCache( static_cast<VkDevice>( m_device ),
3517 reinterpret_cast<const VkPipelineCacheCreateInfo *>( pCreateInfo ),
3518 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
3519 reinterpret_cast<VkPipelineCache *>( pPipelineCache ) ) );
3520 }
3521
3522 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3523 // wrapper function for command vkCreatePipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineCache.html
3524 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
3525 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<PipelineCache>::type
3526 Device::createPipelineCache( const PipelineCacheCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
3527 {
3528 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
3529 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
3530 VULKAN_HPP_ASSERT( d.vkCreatePipelineCache && "Function <vkCreatePipelineCache> requires <VK_VERSION_1_0>" );
3531 # endif
3532
3533 PipelineCache pipelineCache;
3534 Result result = static_cast<Result>( d.vkCreatePipelineCache( m_device,
3535 reinterpret_cast<const VkPipelineCacheCreateInfo *>( &createInfo ),
3536 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
3537 reinterpret_cast<VkPipelineCache *>( &pipelineCache ) ) );
3538 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineCache" );
3539
3540 return detail::createResultValueType( result, std::move( pipelineCache ) );
3541 }
3542
3543 # ifndef VULKAN_HPP_NO_SMART_HANDLE
3544 // wrapper function for command vkCreatePipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineCache.html
3545 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
3546 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<PipelineCache, Dispatch>>::type
3547 Device::createPipelineCacheUnique( const PipelineCacheCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
3548 {
3549 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
3550 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
3551 VULKAN_HPP_ASSERT( d.vkCreatePipelineCache && "Function <vkCreatePipelineCache> requires <VK_VERSION_1_0>" );
3552 # endif
3553
3554 PipelineCache pipelineCache;
3555 Result result = static_cast<Result>( d.vkCreatePipelineCache( m_device,
3556 reinterpret_cast<const VkPipelineCacheCreateInfo *>( &createInfo ),
3557 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
3558 reinterpret_cast<VkPipelineCache *>( &pipelineCache ) ) );
3559 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineCacheUnique" );
3560
3561 return detail::createResultValueType(
3562 result, UniqueHandle<PipelineCache, Dispatch>( pipelineCache, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
3563 }
3564 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
3565 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3566
3567 // wrapper function for command vkDestroyPipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineCache.html
3568 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
3569 VULKAN_HPP_INLINE void
3570 Device::destroyPipelineCache( PipelineCache pipelineCache, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
3571 {
3572 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
3573 d.vkDestroyPipelineCache(
3574 static_cast<VkDevice>( m_device ), static_cast<VkPipelineCache>( pipelineCache ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
3575 }
3576
3577 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3578 // wrapper function for command vkDestroyPipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineCache.html
3579 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
3580 VULKAN_HPP_INLINE void
3581 Device::destroyPipelineCache( PipelineCache pipelineCache, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
3582 {
3583 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
3584 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
3585 VULKAN_HPP_ASSERT( d.vkDestroyPipelineCache && "Function <vkDestroyPipelineCache> requires <VK_VERSION_1_0>" );
3586 # endif
3587
3588 d.vkDestroyPipelineCache( m_device, static_cast<VkPipelineCache>( pipelineCache ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
3589 }
3590 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3591
3592 // wrapper function for command vkDestroyPipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineCache.html
3593 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
3594 VULKAN_HPP_INLINE void Device::destroy( PipelineCache pipelineCache, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
3595 {
3596 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
3597 d.vkDestroyPipelineCache(
3598 static_cast<VkDevice>( m_device ), static_cast<VkPipelineCache>( pipelineCache ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
3599 }
3600
3601 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3602 // wrapper function for command vkDestroyPipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineCache.html
3603 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
3604 VULKAN_HPP_INLINE void
3605 Device::destroy( PipelineCache pipelineCache, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
3606 {
3607 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
3608 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
3609 VULKAN_HPP_ASSERT( d.vkDestroyPipelineCache && "Function <vkDestroyPipelineCache> requires <VK_VERSION_1_0>" );
3610 # endif
3611
3612 d.vkDestroyPipelineCache( m_device, static_cast<VkPipelineCache>( pipelineCache ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
3613 }
3614 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3615
3616 // wrapper function for command vkGetPipelineCacheData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineCacheData.html
3617 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
3618 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
3619 Device::getPipelineCacheData( PipelineCache pipelineCache, size_t * pDataSize, void * pData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
3620 {
3621 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
3622 return static_cast<Result>(
3623 d.vkGetPipelineCacheData( static_cast<VkDevice>( m_device ), static_cast<VkPipelineCache>( pipelineCache ), pDataSize, pData ) );
3624 }
3625
3626 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3627 // wrapper function for command vkGetPipelineCacheData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineCacheData.html
3628 template <typename Uint8_tAllocator,
3629 typename Dispatch,
3630 typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type,
3631 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
3632 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
3633 Device::getPipelineCacheData( PipelineCache pipelineCache, Dispatch const & d ) const
3634 {
3635 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
3636 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
3637 VULKAN_HPP_ASSERT( d.vkGetPipelineCacheData && "Function <vkGetPipelineCacheData> requires <VK_VERSION_1_0>" );
3638 # endif
3639
3640 std::vector<uint8_t, Uint8_tAllocator> data;
3641 size_t dataSize;
3642 Result result;
3643 do
3644 {
3645 result = static_cast<Result>( d.vkGetPipelineCacheData( m_device, static_cast<VkPipelineCache>( pipelineCache ), &dataSize, nullptr ) );
3646 if ( ( result == Result::eSuccess ) && dataSize )
3647 {
3648 data.resize( dataSize );
3649 result = static_cast<Result>(
3650 d.vkGetPipelineCacheData( m_device, static_cast<VkPipelineCache>( pipelineCache ), &dataSize, reinterpret_cast<void *>( data.data() ) ) );
3651 }
3652 } while ( result == Result::eIncomplete );
3653 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineCacheData" );
3654 VULKAN_HPP_ASSERT( dataSize <= data.size() );
3655 if ( dataSize < data.size() )
3656 {
3657 data.resize( dataSize );
3658 }
3659 return detail::createResultValueType( result, std::move( data ) );
3660 }
3661
3662 // wrapper function for command vkGetPipelineCacheData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineCacheData.html
3663 template <typename Uint8_tAllocator,
3664 typename Dispatch,
3665 typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type,
3666 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
3667 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
3668 Device::getPipelineCacheData( PipelineCache pipelineCache, Uint8_tAllocator & uint8_tAllocator, Dispatch const & d ) const
3669 {
3670 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
3671 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
3672 VULKAN_HPP_ASSERT( d.vkGetPipelineCacheData && "Function <vkGetPipelineCacheData> requires <VK_VERSION_1_0>" );
3673 # endif
3674
3675 std::vector<uint8_t, Uint8_tAllocator> data( uint8_tAllocator );
3676 size_t dataSize;
3677 Result result;
3678 do
3679 {
3680 result = static_cast<Result>( d.vkGetPipelineCacheData( m_device, static_cast<VkPipelineCache>( pipelineCache ), &dataSize, nullptr ) );
3681 if ( ( result == Result::eSuccess ) && dataSize )
3682 {
3683 data.resize( dataSize );
3684 result = static_cast<Result>(
3685 d.vkGetPipelineCacheData( m_device, static_cast<VkPipelineCache>( pipelineCache ), &dataSize, reinterpret_cast<void *>( data.data() ) ) );
3686 }
3687 } while ( result == Result::eIncomplete );
3688 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineCacheData" );
3689 VULKAN_HPP_ASSERT( dataSize <= data.size() );
3690 if ( dataSize < data.size() )
3691 {
3692 data.resize( dataSize );
3693 }
3694 return detail::createResultValueType( result, std::move( data ) );
3695 }
3696 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3697
3698 // wrapper function for command vkMergePipelineCaches, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMergePipelineCaches.html
3699 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
3700 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::mergePipelineCaches( PipelineCache dstCache,
3701 uint32_t srcCacheCount,
3702 const PipelineCache * pSrcCaches,
3703 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
3704 {
3705 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
3706 return static_cast<Result>( d.vkMergePipelineCaches(
3707 static_cast<VkDevice>( m_device ), static_cast<VkPipelineCache>( dstCache ), srcCacheCount, reinterpret_cast<const VkPipelineCache *>( pSrcCaches ) ) );
3708 }
3709
3710 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3711 // wrapper function for command vkMergePipelineCaches, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMergePipelineCaches.html
3712 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
3713 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
3714 Device::mergePipelineCaches( PipelineCache dstCache, ArrayProxy<const PipelineCache> const & srcCaches, Dispatch const & d ) const
3715 {
3716 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
3717 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
3718 VULKAN_HPP_ASSERT( d.vkMergePipelineCaches && "Function <vkMergePipelineCaches> requires <VK_VERSION_1_0>" );
3719 # endif
3720
3721 Result result = static_cast<Result>( d.vkMergePipelineCaches(
3722 m_device, static_cast<VkPipelineCache>( dstCache ), srcCaches.size(), reinterpret_cast<const VkPipelineCache *>( srcCaches.data() ) ) );
3723 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::mergePipelineCaches" );
3724
3725 return detail::createResultValueType( result );
3726 }
3727 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3728
3729 // wrapper function for command vkCreateComputePipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateComputePipelines.html
3730 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
3731 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createComputePipelines( PipelineCache pipelineCache,
3732 uint32_t createInfoCount,
3733 const ComputePipelineCreateInfo * pCreateInfos,
3734 const AllocationCallbacks * pAllocator,
3735 Pipeline * pPipelines,
3736 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
3737 {
3738 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
3739 return static_cast<Result>( d.vkCreateComputePipelines( static_cast<VkDevice>( m_device ),
3740 static_cast<VkPipelineCache>( pipelineCache ),
3741 createInfoCount,
3742 reinterpret_cast<const VkComputePipelineCreateInfo *>( pCreateInfos ),
3743 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
3744 reinterpret_cast<VkPipeline *>( pPipelines ) ) );
3745 }
3746
3747 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3748 // wrapper function for command vkCreateComputePipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateComputePipelines.html
3749 template <typename PipelineAllocator,
3750 typename Dispatch,
3751 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, Pipeline>::value, int>::type,
3752 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
3753 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<Pipeline, PipelineAllocator>>
3754 Device::createComputePipelines( PipelineCache pipelineCache,
3755 ArrayProxy<const ComputePipelineCreateInfo> const & createInfos,
3756 Optional<const AllocationCallbacks> allocator,
3757 Dispatch const & d ) const
3758 {
3759 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
3760 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
3761 VULKAN_HPP_ASSERT( d.vkCreateComputePipelines && "Function <vkCreateComputePipelines> requires <VK_VERSION_1_0>" );
3762 # endif
3763
3764 std::vector<Pipeline, PipelineAllocator> pipelines( createInfos.size() );
3765 Result result = static_cast<Result>( d.vkCreateComputePipelines( m_device,
3766 static_cast<VkPipelineCache>( pipelineCache ),
3767 createInfos.size(),
3768 reinterpret_cast<const VkComputePipelineCreateInfo *>( createInfos.data() ),
3769 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
3770 reinterpret_cast<VkPipeline *>( pipelines.data() ) ) );
3771 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelines", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } );
3772
3773 return ResultValue<std::vector<Pipeline, PipelineAllocator>>( result, std::move( pipelines ) );
3774 }
3775
3776 // wrapper function for command vkCreateComputePipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateComputePipelines.html
3777 template <typename PipelineAllocator,
3778 typename Dispatch,
3779 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, Pipeline>::value, int>::type,
3780 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
3781 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<Pipeline, PipelineAllocator>>
3782 Device::createComputePipelines( PipelineCache pipelineCache,
3783 ArrayProxy<const ComputePipelineCreateInfo> const & createInfos,
3784 Optional<const AllocationCallbacks> allocator,
3785 PipelineAllocator & pipelineAllocator,
3786 Dispatch const & d ) const
3787 {
3788 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
3789 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
3790 VULKAN_HPP_ASSERT( d.vkCreateComputePipelines && "Function <vkCreateComputePipelines> requires <VK_VERSION_1_0>" );
3791 # endif
3792
3793 std::vector<Pipeline, PipelineAllocator> pipelines( createInfos.size(), pipelineAllocator );
3794 Result result = static_cast<Result>( d.vkCreateComputePipelines( m_device,
3795 static_cast<VkPipelineCache>( pipelineCache ),
3796 createInfos.size(),
3797 reinterpret_cast<const VkComputePipelineCreateInfo *>( createInfos.data() ),
3798 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
3799 reinterpret_cast<VkPipeline *>( pipelines.data() ) ) );
3800 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelines", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } );
3801
3802 return ResultValue<std::vector<Pipeline, PipelineAllocator>>( result, std::move( pipelines ) );
3803 }
3804
3805 // wrapper function for command vkCreateComputePipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateComputePipelines.html
3806 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
3807 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<Pipeline> Device::createComputePipeline( PipelineCache pipelineCache,
3808 const ComputePipelineCreateInfo & createInfo,
3809 Optional<const AllocationCallbacks> allocator,
3810 Dispatch const & d ) const
3811 {
3812 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
3813 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
3814 VULKAN_HPP_ASSERT( d.vkCreateComputePipelines && "Function <vkCreateComputePipelines> requires <VK_VERSION_1_0>" );
3815 # endif
3816
3817 Pipeline pipeline;
3818 Result result = static_cast<Result>( d.vkCreateComputePipelines( m_device,
3819 static_cast<VkPipelineCache>( pipelineCache ),
3820 1,
3821 reinterpret_cast<const VkComputePipelineCreateInfo *>( &createInfo ),
3822 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
3823 reinterpret_cast<VkPipeline *>( &pipeline ) ) );
3824 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipeline", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } );
3825
3826 return ResultValue<Pipeline>( result, std::move( pipeline ) );
3827 }
3828
3829 # ifndef VULKAN_HPP_NO_SMART_HANDLE
3830 // wrapper function for command vkCreateComputePipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateComputePipelines.html
3831 template <typename Dispatch,
3832 typename PipelineAllocator,
3833 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<Pipeline, Dispatch>>::value, int>::type,
3834 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
3835 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
3836 Device::createComputePipelinesUnique( PipelineCache pipelineCache,
3837 ArrayProxy<const ComputePipelineCreateInfo> const & createInfos,
3838 Optional<const AllocationCallbacks> allocator,
3839 Dispatch const & d ) const
3840 {
3841 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
3842 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
3843 VULKAN_HPP_ASSERT( d.vkCreateComputePipelines && "Function <vkCreateComputePipelines> requires <VK_VERSION_1_0>" );
3844 # endif
3845
3846 std::vector<Pipeline> pipelines( createInfos.size() );
3847 Result result = static_cast<Result>( d.vkCreateComputePipelines( m_device,
3848 static_cast<VkPipelineCache>( pipelineCache ),
3849 createInfos.size(),
3850 reinterpret_cast<const VkComputePipelineCreateInfo *>( createInfos.data() ),
3851 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
3852 reinterpret_cast<VkPipeline *>( pipelines.data() ) ) );
3853 detail::resultCheck(
3854 result, VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelinesUnique", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } );
3855 std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator> uniquePipelines;
3856 uniquePipelines.reserve( createInfos.size() );
3857 detail::ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
3858 for ( auto const & pipeline : pipelines )
3859 {
3860 uniquePipelines.push_back( UniqueHandle<Pipeline, Dispatch>( pipeline, deleter ) );
3861 }
3862 return ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>( result, std::move( uniquePipelines ) );
3863 }
3864
3865 // wrapper function for command vkCreateComputePipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateComputePipelines.html
3866 template <typename Dispatch,
3867 typename PipelineAllocator,
3868 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<Pipeline, Dispatch>>::value, int>::type,
3869 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
3870 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
3871 Device::createComputePipelinesUnique( PipelineCache pipelineCache,
3872 ArrayProxy<const ComputePipelineCreateInfo> const & createInfos,
3873 Optional<const AllocationCallbacks> allocator,
3874 PipelineAllocator & pipelineAllocator,
3875 Dispatch const & d ) const
3876 {
3877 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
3878 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
3879 VULKAN_HPP_ASSERT( d.vkCreateComputePipelines && "Function <vkCreateComputePipelines> requires <VK_VERSION_1_0>" );
3880 # endif
3881
3882 std::vector<Pipeline> pipelines( createInfos.size() );
3883 Result result = static_cast<Result>( d.vkCreateComputePipelines( m_device,
3884 static_cast<VkPipelineCache>( pipelineCache ),
3885 createInfos.size(),
3886 reinterpret_cast<const VkComputePipelineCreateInfo *>( createInfos.data() ),
3887 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
3888 reinterpret_cast<VkPipeline *>( pipelines.data() ) ) );
3889 detail::resultCheck(
3890 result, VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelinesUnique", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } );
3891 std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator> uniquePipelines( pipelineAllocator );
3892 uniquePipelines.reserve( createInfos.size() );
3893 detail::ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
3894 for ( auto const & pipeline : pipelines )
3895 {
3896 uniquePipelines.push_back( UniqueHandle<Pipeline, Dispatch>( pipeline, deleter ) );
3897 }
3898 return ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>( result, std::move( uniquePipelines ) );
3899 }
3900
3901 // wrapper function for command vkCreateComputePipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateComputePipelines.html
3902 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
3903 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<UniqueHandle<Pipeline, Dispatch>> Device::createComputePipelineUnique(
3904 PipelineCache pipelineCache, const ComputePipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
3905 {
3906 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
3907 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
3908 VULKAN_HPP_ASSERT( d.vkCreateComputePipelines && "Function <vkCreateComputePipelines> requires <VK_VERSION_1_0>" );
3909 # endif
3910
3911 Pipeline pipeline;
3912 Result result = static_cast<Result>( d.vkCreateComputePipelines( m_device,
3913 static_cast<VkPipelineCache>( pipelineCache ),
3914 1,
3915 reinterpret_cast<const VkComputePipelineCreateInfo *>( &createInfo ),
3916 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
3917 reinterpret_cast<VkPipeline *>( &pipeline ) ) );
3918 detail::resultCheck(
3919 result, VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelineUnique", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } );
3920
3921 return ResultValue<UniqueHandle<Pipeline, Dispatch>>(
3922 result, UniqueHandle<Pipeline, Dispatch>( pipeline, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
3923 }
3924 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
3925 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3926
3927 // wrapper function for command vkDestroyPipeline, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipeline.html
3928 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
3929 VULKAN_HPP_INLINE void Device::destroyPipeline( Pipeline pipeline, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
3930 {
3931 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
3932 d.vkDestroyPipeline(
3933 static_cast<VkDevice>( m_device ), static_cast<VkPipeline>( pipeline ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
3934 }
3935
3936 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3937 // wrapper function for command vkDestroyPipeline, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipeline.html
3938 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
3939 VULKAN_HPP_INLINE void
3940 Device::destroyPipeline( Pipeline pipeline, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
3941 {
3942 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
3943 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
3944 VULKAN_HPP_ASSERT( d.vkDestroyPipeline && "Function <vkDestroyPipeline> requires <VK_VERSION_1_0>" );
3945 # endif
3946
3947 d.vkDestroyPipeline( m_device, static_cast<VkPipeline>( pipeline ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
3948 }
3949 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3950
3951 // wrapper function for command vkDestroyPipeline, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipeline.html
3952 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
3953 VULKAN_HPP_INLINE void Device::destroy( Pipeline pipeline, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
3954 {
3955 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
3956 d.vkDestroyPipeline(
3957 static_cast<VkDevice>( m_device ), static_cast<VkPipeline>( pipeline ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
3958 }
3959
3960 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3961 // wrapper function for command vkDestroyPipeline, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipeline.html
3962 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
3963 VULKAN_HPP_INLINE void Device::destroy( Pipeline pipeline, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
3964 {
3965 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
3966 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
3967 VULKAN_HPP_ASSERT( d.vkDestroyPipeline && "Function <vkDestroyPipeline> requires <VK_VERSION_1_0>" );
3968 # endif
3969
3970 d.vkDestroyPipeline( m_device, static_cast<VkPipeline>( pipeline ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
3971 }
3972 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3973
3974 // wrapper function for command vkCreatePipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineLayout.html
3975 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
3976 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createPipelineLayout( const PipelineLayoutCreateInfo * pCreateInfo,
3977 const AllocationCallbacks * pAllocator,
3978 PipelineLayout * pPipelineLayout,
3979 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
3980 {
3981 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
3982 return static_cast<Result>( d.vkCreatePipelineLayout( static_cast<VkDevice>( m_device ),
3983 reinterpret_cast<const VkPipelineLayoutCreateInfo *>( pCreateInfo ),
3984 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
3985 reinterpret_cast<VkPipelineLayout *>( pPipelineLayout ) ) );
3986 }
3987
3988 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3989 // wrapper function for command vkCreatePipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineLayout.html
3990 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
3991 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<PipelineLayout>::type
3992 Device::createPipelineLayout( const PipelineLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
3993 {
3994 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
3995 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
3996 VULKAN_HPP_ASSERT( d.vkCreatePipelineLayout && "Function <vkCreatePipelineLayout> requires <VK_VERSION_1_0>" );
3997 # endif
3998
3999 PipelineLayout pipelineLayout;
4000 Result result = static_cast<Result>( d.vkCreatePipelineLayout( m_device,
4001 reinterpret_cast<const VkPipelineLayoutCreateInfo *>( &createInfo ),
4002 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
4003 reinterpret_cast<VkPipelineLayout *>( &pipelineLayout ) ) );
4004 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineLayout" );
4005
4006 return detail::createResultValueType( result, std::move( pipelineLayout ) );
4007 }
4008
4009 # ifndef VULKAN_HPP_NO_SMART_HANDLE
4010 // wrapper function for command vkCreatePipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineLayout.html
4011 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
4012 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<PipelineLayout, Dispatch>>::type
4013 Device::createPipelineLayoutUnique( const PipelineLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
4014 {
4015 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
4016 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
4017 VULKAN_HPP_ASSERT( d.vkCreatePipelineLayout && "Function <vkCreatePipelineLayout> requires <VK_VERSION_1_0>" );
4018 # endif
4019
4020 PipelineLayout pipelineLayout;
4021 Result result = static_cast<Result>( d.vkCreatePipelineLayout( m_device,
4022 reinterpret_cast<const VkPipelineLayoutCreateInfo *>( &createInfo ),
4023 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
4024 reinterpret_cast<VkPipelineLayout *>( &pipelineLayout ) ) );
4025 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineLayoutUnique" );
4026
4027 return detail::createResultValueType(
4028 result, UniqueHandle<PipelineLayout, Dispatch>( pipelineLayout, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
4029 }
4030 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
4031 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4032
4033 // wrapper function for command vkDestroyPipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineLayout.html
4034 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
4035 VULKAN_HPP_INLINE void
4036 Device::destroyPipelineLayout( PipelineLayout pipelineLayout, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
4037 {
4038 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
4039 d.vkDestroyPipelineLayout(
4040 static_cast<VkDevice>( m_device ), static_cast<VkPipelineLayout>( pipelineLayout ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
4041 }
4042
4043 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4044 // wrapper function for command vkDestroyPipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineLayout.html
4045 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
4046 VULKAN_HPP_INLINE void
4047 Device::destroyPipelineLayout( PipelineLayout pipelineLayout, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
4048 {
4049 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
4050 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
4051 VULKAN_HPP_ASSERT( d.vkDestroyPipelineLayout && "Function <vkDestroyPipelineLayout> requires <VK_VERSION_1_0>" );
4052 # endif
4053
4054 d.vkDestroyPipelineLayout( m_device, static_cast<VkPipelineLayout>( pipelineLayout ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
4055 }
4056 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4057
4058 // wrapper function for command vkDestroyPipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineLayout.html
4059 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
4060 VULKAN_HPP_INLINE void Device::destroy( PipelineLayout pipelineLayout, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
4061 {
4062 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
4063 d.vkDestroyPipelineLayout(
4064 static_cast<VkDevice>( m_device ), static_cast<VkPipelineLayout>( pipelineLayout ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
4065 }
4066
4067 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4068 // wrapper function for command vkDestroyPipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineLayout.html
4069 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
4070 VULKAN_HPP_INLINE void
4071 Device::destroy( PipelineLayout pipelineLayout, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
4072 {
4073 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
4074 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
4075 VULKAN_HPP_ASSERT( d.vkDestroyPipelineLayout && "Function <vkDestroyPipelineLayout> requires <VK_VERSION_1_0>" );
4076 # endif
4077
4078 d.vkDestroyPipelineLayout( m_device, static_cast<VkPipelineLayout>( pipelineLayout ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
4079 }
4080 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4081
4082 // wrapper function for command vkCreateSampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSampler.html
4083 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
4084 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createSampler( const SamplerCreateInfo * pCreateInfo,
4085 const AllocationCallbacks * pAllocator,
4086 Sampler * pSampler,
4087 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
4088 {
4089 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
4090 return static_cast<Result>( d.vkCreateSampler( static_cast<VkDevice>( m_device ),
4091 reinterpret_cast<const VkSamplerCreateInfo *>( pCreateInfo ),
4092 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
4093 reinterpret_cast<VkSampler *>( pSampler ) ) );
4094 }
4095
4096 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4097 // wrapper function for command vkCreateSampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSampler.html
4098 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
4099 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<Sampler>::type
4100 Device::createSampler( const SamplerCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
4101 {
4102 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
4103 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
4104 VULKAN_HPP_ASSERT( d.vkCreateSampler && "Function <vkCreateSampler> requires <VK_VERSION_1_0>" );
4105 # endif
4106
4107 Sampler sampler;
4108 Result result = static_cast<Result>( d.vkCreateSampler( m_device,
4109 reinterpret_cast<const VkSamplerCreateInfo *>( &createInfo ),
4110 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
4111 reinterpret_cast<VkSampler *>( &sampler ) ) );
4112 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSampler" );
4113
4114 return detail::createResultValueType( result, std::move( sampler ) );
4115 }
4116
4117 # ifndef VULKAN_HPP_NO_SMART_HANDLE
4118 // wrapper function for command vkCreateSampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSampler.html
4119 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
4120 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Sampler, Dispatch>>::type
4121 Device::createSamplerUnique( const SamplerCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
4122 {
4123 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
4124 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
4125 VULKAN_HPP_ASSERT( d.vkCreateSampler && "Function <vkCreateSampler> requires <VK_VERSION_1_0>" );
4126 # endif
4127
4128 Sampler sampler;
4129 Result result = static_cast<Result>( d.vkCreateSampler( m_device,
4130 reinterpret_cast<const VkSamplerCreateInfo *>( &createInfo ),
4131 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
4132 reinterpret_cast<VkSampler *>( &sampler ) ) );
4133 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSamplerUnique" );
4134
4135 return detail::createResultValueType( result, UniqueHandle<Sampler, Dispatch>( sampler, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
4136 }
4137 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
4138 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4139
4140 // wrapper function for command vkDestroySampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySampler.html
4141 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
4142 VULKAN_HPP_INLINE void Device::destroySampler( Sampler sampler, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
4143 {
4144 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
4145 d.vkDestroySampler( static_cast<VkDevice>( m_device ), static_cast<VkSampler>( sampler ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
4146 }
4147
4148 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4149 // wrapper function for command vkDestroySampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySampler.html
4150 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
4151 VULKAN_HPP_INLINE void Device::destroySampler( Sampler sampler, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
4152 {
4153 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
4154 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
4155 VULKAN_HPP_ASSERT( d.vkDestroySampler && "Function <vkDestroySampler> requires <VK_VERSION_1_0>" );
4156 # endif
4157
4158 d.vkDestroySampler( m_device, static_cast<VkSampler>( sampler ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
4159 }
4160 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4161
4162 // wrapper function for command vkDestroySampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySampler.html
4163 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
4164 VULKAN_HPP_INLINE void Device::destroy( Sampler sampler, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
4165 {
4166 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
4167 d.vkDestroySampler( static_cast<VkDevice>( m_device ), static_cast<VkSampler>( sampler ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
4168 }
4169
4170 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4171 // wrapper function for command vkDestroySampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySampler.html
4172 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
4173 VULKAN_HPP_INLINE void Device::destroy( Sampler sampler, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
4174 {
4175 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
4176 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
4177 VULKAN_HPP_ASSERT( d.vkDestroySampler && "Function <vkDestroySampler> requires <VK_VERSION_1_0>" );
4178 # endif
4179
4180 d.vkDestroySampler( m_device, static_cast<VkSampler>( sampler ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
4181 }
4182 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4183
4184 // wrapper function for command vkCreateDescriptorSetLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorSetLayout.html
4185 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
4186 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createDescriptorSetLayout( const DescriptorSetLayoutCreateInfo * pCreateInfo,
4187 const AllocationCallbacks * pAllocator,
4188 DescriptorSetLayout * pSetLayout,
4189 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
4190 {
4191 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
4192 return static_cast<Result>( d.vkCreateDescriptorSetLayout( static_cast<VkDevice>( m_device ),
4193 reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( pCreateInfo ),
4194 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
4195 reinterpret_cast<VkDescriptorSetLayout *>( pSetLayout ) ) );
4196 }
4197
4198 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4199 // wrapper function for command vkCreateDescriptorSetLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorSetLayout.html
4200 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
4201 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<DescriptorSetLayout>::type Device::createDescriptorSetLayout(
4202 const DescriptorSetLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
4203 {
4204 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
4205 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
4206 VULKAN_HPP_ASSERT( d.vkCreateDescriptorSetLayout && "Function <vkCreateDescriptorSetLayout> requires <VK_VERSION_1_0>" );
4207 # endif
4208
4209 DescriptorSetLayout setLayout;
4210 Result result = static_cast<Result>( d.vkCreateDescriptorSetLayout( m_device,
4211 reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( &createInfo ),
4212 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
4213 reinterpret_cast<VkDescriptorSetLayout *>( &setLayout ) ) );
4214 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorSetLayout" );
4215
4216 return detail::createResultValueType( result, std::move( setLayout ) );
4217 }
4218
4219 # ifndef VULKAN_HPP_NO_SMART_HANDLE
4220 // wrapper function for command vkCreateDescriptorSetLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorSetLayout.html
4221 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
4222 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<DescriptorSetLayout, Dispatch>>::type Device::createDescriptorSetLayoutUnique(
4223 const DescriptorSetLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
4224 {
4225 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
4226 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
4227 VULKAN_HPP_ASSERT( d.vkCreateDescriptorSetLayout && "Function <vkCreateDescriptorSetLayout> requires <VK_VERSION_1_0>" );
4228 # endif
4229
4230 DescriptorSetLayout setLayout;
4231 Result result = static_cast<Result>( d.vkCreateDescriptorSetLayout( m_device,
4232 reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( &createInfo ),
4233 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
4234 reinterpret_cast<VkDescriptorSetLayout *>( &setLayout ) ) );
4235 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorSetLayoutUnique" );
4236
4237 return detail::createResultValueType(
4238 result, UniqueHandle<DescriptorSetLayout, Dispatch>( setLayout, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
4239 }
4240 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
4241 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4242
4243 // wrapper function for command vkDestroyDescriptorSetLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorSetLayout.html
4244 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
4245 VULKAN_HPP_INLINE void Device::destroyDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout,
4246 const AllocationCallbacks * pAllocator,
4247 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
4248 {
4249 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
4250 d.vkDestroyDescriptorSetLayout( static_cast<VkDevice>( m_device ),
4251 static_cast<VkDescriptorSetLayout>( descriptorSetLayout ),
4252 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
4253 }
4254
4255 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4256 // wrapper function for command vkDestroyDescriptorSetLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorSetLayout.html
4257 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
4258 VULKAN_HPP_INLINE void Device::destroyDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout,
4259 Optional<const AllocationCallbacks> allocator,
4260 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
4261 {
4262 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
4263 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
4264 VULKAN_HPP_ASSERT( d.vkDestroyDescriptorSetLayout && "Function <vkDestroyDescriptorSetLayout> requires <VK_VERSION_1_0>" );
4265 # endif
4266
4267 d.vkDestroyDescriptorSetLayout(
4268 m_device, static_cast<VkDescriptorSetLayout>( descriptorSetLayout ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
4269 }
4270 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4271
4272 // wrapper function for command vkDestroyDescriptorSetLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorSetLayout.html
4273 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
4274 VULKAN_HPP_INLINE void
4275 Device::destroy( DescriptorSetLayout descriptorSetLayout, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
4276 {
4277 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
4278 d.vkDestroyDescriptorSetLayout( static_cast<VkDevice>( m_device ),
4279 static_cast<VkDescriptorSetLayout>( descriptorSetLayout ),
4280 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
4281 }
4282
4283 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4284 // wrapper function for command vkDestroyDescriptorSetLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorSetLayout.html
4285 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
4286 VULKAN_HPP_INLINE void
4287 Device::destroy( DescriptorSetLayout descriptorSetLayout, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
4288 {
4289 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
4290 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
4291 VULKAN_HPP_ASSERT( d.vkDestroyDescriptorSetLayout && "Function <vkDestroyDescriptorSetLayout> requires <VK_VERSION_1_0>" );
4292 # endif
4293
4294 d.vkDestroyDescriptorSetLayout(
4295 m_device, static_cast<VkDescriptorSetLayout>( descriptorSetLayout ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
4296 }
4297 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4298
4299 // wrapper function for command vkCreateDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorPool.html
4300 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
4301 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createDescriptorPool( const DescriptorPoolCreateInfo * pCreateInfo,
4302 const AllocationCallbacks * pAllocator,
4303 DescriptorPool * pDescriptorPool,
4304 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
4305 {
4306 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
4307 return static_cast<Result>( d.vkCreateDescriptorPool( static_cast<VkDevice>( m_device ),
4308 reinterpret_cast<const VkDescriptorPoolCreateInfo *>( pCreateInfo ),
4309 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
4310 reinterpret_cast<VkDescriptorPool *>( pDescriptorPool ) ) );
4311 }
4312
4313 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4314 // wrapper function for command vkCreateDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorPool.html
4315 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
4316 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<DescriptorPool>::type
4317 Device::createDescriptorPool( const DescriptorPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
4318 {
4319 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
4320 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
4321 VULKAN_HPP_ASSERT( d.vkCreateDescriptorPool && "Function <vkCreateDescriptorPool> requires <VK_VERSION_1_0>" );
4322 # endif
4323
4324 DescriptorPool descriptorPool;
4325 Result result = static_cast<Result>( d.vkCreateDescriptorPool( m_device,
4326 reinterpret_cast<const VkDescriptorPoolCreateInfo *>( &createInfo ),
4327 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
4328 reinterpret_cast<VkDescriptorPool *>( &descriptorPool ) ) );
4329 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorPool" );
4330
4331 return detail::createResultValueType( result, std::move( descriptorPool ) );
4332 }
4333
4334 # ifndef VULKAN_HPP_NO_SMART_HANDLE
4335 // wrapper function for command vkCreateDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorPool.html
4336 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
4337 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<DescriptorPool, Dispatch>>::type
4338 Device::createDescriptorPoolUnique( const DescriptorPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
4339 {
4340 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
4341 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
4342 VULKAN_HPP_ASSERT( d.vkCreateDescriptorPool && "Function <vkCreateDescriptorPool> requires <VK_VERSION_1_0>" );
4343 # endif
4344
4345 DescriptorPool descriptorPool;
4346 Result result = static_cast<Result>( d.vkCreateDescriptorPool( m_device,
4347 reinterpret_cast<const VkDescriptorPoolCreateInfo *>( &createInfo ),
4348 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
4349 reinterpret_cast<VkDescriptorPool *>( &descriptorPool ) ) );
4350 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorPoolUnique" );
4351
4352 return detail::createResultValueType(
4353 result, UniqueHandle<DescriptorPool, Dispatch>( descriptorPool, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
4354 }
4355 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
4356 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4357
4358 // wrapper function for command vkDestroyDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorPool.html
4359 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
4360 VULKAN_HPP_INLINE void
4361 Device::destroyDescriptorPool( DescriptorPool descriptorPool, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
4362 {
4363 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
4364 d.vkDestroyDescriptorPool(
4365 static_cast<VkDevice>( m_device ), static_cast<VkDescriptorPool>( descriptorPool ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
4366 }
4367
4368 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4369 // wrapper function for command vkDestroyDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorPool.html
4370 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
4371 VULKAN_HPP_INLINE void
4372 Device::destroyDescriptorPool( DescriptorPool descriptorPool, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
4373 {
4374 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
4375 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
4376 VULKAN_HPP_ASSERT( d.vkDestroyDescriptorPool && "Function <vkDestroyDescriptorPool> requires <VK_VERSION_1_0>" );
4377 # endif
4378
4379 d.vkDestroyDescriptorPool( m_device, static_cast<VkDescriptorPool>( descriptorPool ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
4380 }
4381 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4382
4383 // wrapper function for command vkDestroyDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorPool.html
4384 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
4385 VULKAN_HPP_INLINE void Device::destroy( DescriptorPool descriptorPool, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
4386 {
4387 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
4388 d.vkDestroyDescriptorPool(
4389 static_cast<VkDevice>( m_device ), static_cast<VkDescriptorPool>( descriptorPool ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
4390 }
4391
4392 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4393 // wrapper function for command vkDestroyDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorPool.html
4394 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
4395 VULKAN_HPP_INLINE void
4396 Device::destroy( DescriptorPool descriptorPool, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
4397 {
4398 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
4399 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
4400 VULKAN_HPP_ASSERT( d.vkDestroyDescriptorPool && "Function <vkDestroyDescriptorPool> requires <VK_VERSION_1_0>" );
4401 # endif
4402
4403 d.vkDestroyDescriptorPool( m_device, static_cast<VkDescriptorPool>( descriptorPool ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
4404 }
4405 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4406
4407 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
4408 // wrapper function for command vkResetDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetDescriptorPool.html
4409 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
4410 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::resetDescriptorPool( DescriptorPool descriptorPool,
4411 DescriptorPoolResetFlags flags,
4412 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
4413 {
4414 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
4415 return static_cast<Result>( d.vkResetDescriptorPool(
4416 static_cast<VkDevice>( m_device ), static_cast<VkDescriptorPool>( descriptorPool ), static_cast<VkDescriptorPoolResetFlags>( flags ) ) );
4417 }
4418 #else
4419 // wrapper function for command vkResetDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetDescriptorPool.html
4420 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
4421 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
4422 Device::resetDescriptorPool( DescriptorPool descriptorPool, DescriptorPoolResetFlags flags, Dispatch const & d ) const
4423 {
4424 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
4425 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
4426 VULKAN_HPP_ASSERT( d.vkResetDescriptorPool && "Function <vkResetDescriptorPool> requires <VK_VERSION_1_0>" );
4427 # endif
4428
4429 Result result = static_cast<Result>(
4430 d.vkResetDescriptorPool( m_device, static_cast<VkDescriptorPool>( descriptorPool ), static_cast<VkDescriptorPoolResetFlags>( flags ) ) );
4431 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::resetDescriptorPool" );
4432
4433 return detail::createResultValueType( result );
4434 }
4435 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4436
4437 // wrapper function for command vkAllocateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateDescriptorSets.html
4438 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
4439 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::allocateDescriptorSets( const DescriptorSetAllocateInfo * pAllocateInfo,
4440 DescriptorSet * pDescriptorSets,
4441 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
4442 {
4443 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
4444 return static_cast<Result>( d.vkAllocateDescriptorSets( static_cast<VkDevice>( m_device ),
4445 reinterpret_cast<const VkDescriptorSetAllocateInfo *>( pAllocateInfo ),
4446 reinterpret_cast<VkDescriptorSet *>( pDescriptorSets ) ) );
4447 }
4448
4449 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4450 // wrapper function for command vkAllocateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateDescriptorSets.html
4451 template <typename DescriptorSetAllocator,
4452 typename Dispatch,
4453 typename std::enable_if<std::is_same<typename DescriptorSetAllocator::value_type, DescriptorSet>::value, int>::type,
4454 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
4455 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<DescriptorSet, DescriptorSetAllocator>>::type
4456 Device::allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo, Dispatch const & d ) const
4457 {
4458 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
4459 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
4460 VULKAN_HPP_ASSERT( d.vkAllocateDescriptorSets && "Function <vkAllocateDescriptorSets> requires <VK_VERSION_1_0>" );
4461 # endif
4462
4463 std::vector<DescriptorSet, DescriptorSetAllocator> descriptorSets( allocateInfo.descriptorSetCount );
4464 Result result = static_cast<Result>( d.vkAllocateDescriptorSets(
4465 m_device, reinterpret_cast<const VkDescriptorSetAllocateInfo *>( &allocateInfo ), reinterpret_cast<VkDescriptorSet *>( descriptorSets.data() ) ) );
4466 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSets" );
4467
4468 return detail::createResultValueType( result, std::move( descriptorSets ) );
4469 }
4470
4471 // wrapper function for command vkAllocateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateDescriptorSets.html
4472 template <typename DescriptorSetAllocator,
4473 typename Dispatch,
4474 typename std::enable_if<std::is_same<typename DescriptorSetAllocator::value_type, DescriptorSet>::value, int>::type,
4475 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
4476 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<DescriptorSet, DescriptorSetAllocator>>::type
4477 Device::allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo, DescriptorSetAllocator & descriptorSetAllocator, Dispatch const & d ) const
4478 {
4479 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
4480 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
4481 VULKAN_HPP_ASSERT( d.vkAllocateDescriptorSets && "Function <vkAllocateDescriptorSets> requires <VK_VERSION_1_0>" );
4482 # endif
4483
4484 std::vector<DescriptorSet, DescriptorSetAllocator> descriptorSets( allocateInfo.descriptorSetCount, descriptorSetAllocator );
4485 Result result = static_cast<Result>( d.vkAllocateDescriptorSets(
4486 m_device, reinterpret_cast<const VkDescriptorSetAllocateInfo *>( &allocateInfo ), reinterpret_cast<VkDescriptorSet *>( descriptorSets.data() ) ) );
4487 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSets" );
4488
4489 return detail::createResultValueType( result, std::move( descriptorSets ) );
4490 }
4491
4492 # ifndef VULKAN_HPP_NO_SMART_HANDLE
4493 // wrapper function for command vkAllocateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateDescriptorSets.html
4494 template <typename Dispatch,
4495 typename DescriptorSetAllocator,
4496 typename std::enable_if<std::is_same<typename DescriptorSetAllocator::value_type, UniqueHandle<DescriptorSet, Dispatch>>::value, int>::type,
4497 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
4498 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<DescriptorSet, Dispatch>, DescriptorSetAllocator>>::type
4499 Device::allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo, Dispatch const & d ) const
4500 {
4501 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
4502 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
4503 VULKAN_HPP_ASSERT( d.vkAllocateDescriptorSets && "Function <vkAllocateDescriptorSets> requires <VK_VERSION_1_0>" );
4504 # endif
4505
4506 std::vector<DescriptorSet> descriptorSets( allocateInfo.descriptorSetCount );
4507 Result result = static_cast<Result>( d.vkAllocateDescriptorSets(
4508 m_device, reinterpret_cast<const VkDescriptorSetAllocateInfo *>( &allocateInfo ), reinterpret_cast<VkDescriptorSet *>( descriptorSets.data() ) ) );
4509 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSetsUnique" );
4510 std::vector<UniqueHandle<DescriptorSet, Dispatch>, DescriptorSetAllocator> uniqueDescriptorSets;
4511 uniqueDescriptorSets.reserve( allocateInfo.descriptorSetCount );
4512 detail::PoolFree<Device, DescriptorPool, Dispatch> deleter( *this, allocateInfo.descriptorPool, d );
4513 for ( auto const & descriptorSet : descriptorSets )
4514 {
4515 uniqueDescriptorSets.push_back( UniqueHandle<DescriptorSet, Dispatch>( descriptorSet, deleter ) );
4516 }
4517 return detail::createResultValueType( result, std::move( uniqueDescriptorSets ) );
4518 }
4519
4520 // wrapper function for command vkAllocateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateDescriptorSets.html
4521 template <typename Dispatch,
4522 typename DescriptorSetAllocator,
4523 typename std::enable_if<std::is_same<typename DescriptorSetAllocator::value_type, UniqueHandle<DescriptorSet, Dispatch>>::value, int>::type,
4524 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
4525 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<DescriptorSet, Dispatch>, DescriptorSetAllocator>>::type
4526 Device::allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo,
4527 DescriptorSetAllocator & descriptorSetAllocator,
4528 Dispatch const & d ) const
4529 {
4530 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
4531 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
4532 VULKAN_HPP_ASSERT( d.vkAllocateDescriptorSets && "Function <vkAllocateDescriptorSets> requires <VK_VERSION_1_0>" );
4533 # endif
4534
4535 std::vector<DescriptorSet> descriptorSets( allocateInfo.descriptorSetCount );
4536 Result result = static_cast<Result>( d.vkAllocateDescriptorSets(
4537 m_device, reinterpret_cast<const VkDescriptorSetAllocateInfo *>( &allocateInfo ), reinterpret_cast<VkDescriptorSet *>( descriptorSets.data() ) ) );
4538 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSetsUnique" );
4539 std::vector<UniqueHandle<DescriptorSet, Dispatch>, DescriptorSetAllocator> uniqueDescriptorSets( descriptorSetAllocator );
4540 uniqueDescriptorSets.reserve( allocateInfo.descriptorSetCount );
4541 detail::PoolFree<Device, DescriptorPool, Dispatch> deleter( *this, allocateInfo.descriptorPool, d );
4542 for ( auto const & descriptorSet : descriptorSets )
4543 {
4544 uniqueDescriptorSets.push_back( UniqueHandle<DescriptorSet, Dispatch>( descriptorSet, deleter ) );
4545 }
4546 return detail::createResultValueType( result, std::move( uniqueDescriptorSets ) );
4547 }
4548 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
4549 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4550
4551 // wrapper function for command vkFreeDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeDescriptorSets.html
4552 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
4553 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::freeDescriptorSets( DescriptorPool descriptorPool,
4554 uint32_t descriptorSetCount,
4555 const DescriptorSet * pDescriptorSets,
4556 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
4557 {
4558 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
4559 return static_cast<Result>( d.vkFreeDescriptorSets( static_cast<VkDevice>( m_device ),
4560 static_cast<VkDescriptorPool>( descriptorPool ),
4561 descriptorSetCount,
4562 reinterpret_cast<const VkDescriptorSet *>( pDescriptorSets ) ) );
4563 }
4564
4565 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4566 // wrapper function for command vkFreeDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeDescriptorSets.html
4567 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
4568 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
4569 Device::freeDescriptorSets( DescriptorPool descriptorPool, ArrayProxy<const DescriptorSet> const & descriptorSets, Dispatch const & d ) const
4570 {
4571 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
4572 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
4573 VULKAN_HPP_ASSERT( d.vkFreeDescriptorSets && "Function <vkFreeDescriptorSets> requires <VK_VERSION_1_0>" );
4574 # endif
4575
4576 Result result = static_cast<Result>( d.vkFreeDescriptorSets(
4577 m_device, static_cast<VkDescriptorPool>( descriptorPool ), descriptorSets.size(), reinterpret_cast<const VkDescriptorSet *>( descriptorSets.data() ) ) );
4578 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::freeDescriptorSets" );
4579
4580 return detail::createResultValueType( result );
4581 }
4582 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4583
4584 // wrapper function for command vkFreeDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeDescriptorSets.html
4585 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
4586 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result( Device::free )( DescriptorPool descriptorPool,
4587 uint32_t descriptorSetCount,
4588 const DescriptorSet * pDescriptorSets,
4589 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
4590 {
4591 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
4592 return static_cast<Result>( d.vkFreeDescriptorSets( static_cast<VkDevice>( m_device ),
4593 static_cast<VkDescriptorPool>( descriptorPool ),
4594 descriptorSetCount,
4595 reinterpret_cast<const VkDescriptorSet *>( pDescriptorSets ) ) );
4596 }
4597
4598 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4599 // wrapper function for command vkFreeDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeDescriptorSets.html
4600 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
4601 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
4602 typename ResultValueType<void>::type( Device::free )( DescriptorPool descriptorPool,
4603 ArrayProxy<const DescriptorSet> const & descriptorSets,
4604 Dispatch const & d ) const
4605 {
4606 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
4607 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
4608 VULKAN_HPP_ASSERT( d.vkFreeDescriptorSets && "Function <vkFreeDescriptorSets> requires <VK_VERSION_1_0>" );
4609 # endif
4610
4611 Result result = static_cast<Result>( d.vkFreeDescriptorSets(
4612 m_device, static_cast<VkDescriptorPool>( descriptorPool ), descriptorSets.size(), reinterpret_cast<const VkDescriptorSet *>( descriptorSets.data() ) ) );
4613 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::( Device::free )" );
4614
4615 return detail::createResultValueType( result );
4616 }
4617 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4618
4619 // wrapper function for command vkUpdateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateDescriptorSets.html
4620 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
4621 VULKAN_HPP_INLINE void Device::updateDescriptorSets( uint32_t descriptorWriteCount,
4622 const WriteDescriptorSet * pDescriptorWrites,
4623 uint32_t descriptorCopyCount,
4624 const CopyDescriptorSet * pDescriptorCopies,
4625 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
4626 {
4627 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
4628 d.vkUpdateDescriptorSets( static_cast<VkDevice>( m_device ),
4629 descriptorWriteCount,
4630 reinterpret_cast<const VkWriteDescriptorSet *>( pDescriptorWrites ),
4631 descriptorCopyCount,
4632 reinterpret_cast<const VkCopyDescriptorSet *>( pDescriptorCopies ) );
4633 }
4634
4635 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4636 // wrapper function for command vkUpdateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateDescriptorSets.html
4637 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
4638 VULKAN_HPP_INLINE void Device::updateDescriptorSets( ArrayProxy<const WriteDescriptorSet> const & descriptorWrites,
4639 ArrayProxy<const CopyDescriptorSet> const & descriptorCopies,
4640 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
4641 {
4642 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
4643 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
4644 VULKAN_HPP_ASSERT( d.vkUpdateDescriptorSets && "Function <vkUpdateDescriptorSets> requires <VK_VERSION_1_0>" );
4645 # endif
4646
4647 d.vkUpdateDescriptorSets( m_device,
4648 descriptorWrites.size(),
4649 reinterpret_cast<const VkWriteDescriptorSet *>( descriptorWrites.data() ),
4650 descriptorCopies.size(),
4651 reinterpret_cast<const VkCopyDescriptorSet *>( descriptorCopies.data() ) );
4652 }
4653 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4654
4655 // wrapper function for command vkCmdBindPipeline, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindPipeline.html
4656 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
4657 VULKAN_HPP_INLINE void CommandBuffer::bindPipeline( PipelineBindPoint pipelineBindPoint, Pipeline pipeline, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
4658 {
4659 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
4660 d.vkCmdBindPipeline(
4661 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkPipelineBindPoint>( pipelineBindPoint ), static_cast<VkPipeline>( pipeline ) );
4662 }
4663
4664 // wrapper function for command vkCmdBindDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorSets.html
4665 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
4666 VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorSets( PipelineBindPoint pipelineBindPoint,
4667 PipelineLayout layout,
4668 uint32_t firstSet,
4669 uint32_t descriptorSetCount,
4670 const DescriptorSet * pDescriptorSets,
4671 uint32_t dynamicOffsetCount,
4672 const uint32_t * pDynamicOffsets,
4673 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
4674 {
4675 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
4676 d.vkCmdBindDescriptorSets( static_cast<VkCommandBuffer>( m_commandBuffer ),
4677 static_cast<VkPipelineBindPoint>( pipelineBindPoint ),
4678 static_cast<VkPipelineLayout>( layout ),
4679 firstSet,
4680 descriptorSetCount,
4681 reinterpret_cast<const VkDescriptorSet *>( pDescriptorSets ),
4682 dynamicOffsetCount,
4683 pDynamicOffsets );
4684 }
4685
4686 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4687 // wrapper function for command vkCmdBindDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorSets.html
4688 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
4689 VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorSets( PipelineBindPoint pipelineBindPoint,
4690 PipelineLayout layout,
4691 uint32_t firstSet,
4692 ArrayProxy<const DescriptorSet> const & descriptorSets,
4693 ArrayProxy<const uint32_t> const & dynamicOffsets,
4694 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
4695 {
4696 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
4697 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
4698 VULKAN_HPP_ASSERT( d.vkCmdBindDescriptorSets && "Function <vkCmdBindDescriptorSets> requires <VK_VERSION_1_0>" );
4699 # endif
4700
4701 d.vkCmdBindDescriptorSets( m_commandBuffer,
4702 static_cast<VkPipelineBindPoint>( pipelineBindPoint ),
4703 static_cast<VkPipelineLayout>( layout ),
4704 firstSet,
4705 descriptorSets.size(),
4706 reinterpret_cast<const VkDescriptorSet *>( descriptorSets.data() ),
4707 dynamicOffsets.size(),
4708 dynamicOffsets.data() );
4709 }
4710 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4711
4712 // wrapper function for command vkCmdClearColorImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdClearColorImage.html
4713 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
4714 VULKAN_HPP_INLINE void CommandBuffer::clearColorImage( Image image,
4715 ImageLayout imageLayout,
4716 const ClearColorValue * pColor,
4717 uint32_t rangeCount,
4718 const ImageSubresourceRange * pRanges,
4719 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
4720 {
4721 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
4722 d.vkCmdClearColorImage( static_cast<VkCommandBuffer>( m_commandBuffer ),
4723 static_cast<VkImage>( image ),
4724 static_cast<VkImageLayout>( imageLayout ),
4725 reinterpret_cast<const VkClearColorValue *>( pColor ),
4726 rangeCount,
4727 reinterpret_cast<const VkImageSubresourceRange *>( pRanges ) );
4728 }
4729
4730 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4731 // wrapper function for command vkCmdClearColorImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdClearColorImage.html
4732 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
4733 VULKAN_HPP_INLINE void CommandBuffer::clearColorImage( Image image,
4734 ImageLayout imageLayout,
4735 const ClearColorValue & color,
4736 ArrayProxy<const ImageSubresourceRange> const & ranges,
4737 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
4738 {
4739 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
4740 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
4741 VULKAN_HPP_ASSERT( d.vkCmdClearColorImage && "Function <vkCmdClearColorImage> requires <VK_VERSION_1_0>" );
4742 # endif
4743
4744 d.vkCmdClearColorImage( m_commandBuffer,
4745 static_cast<VkImage>( image ),
4746 static_cast<VkImageLayout>( imageLayout ),
4747 reinterpret_cast<const VkClearColorValue *>( &color ),
4748 ranges.size(),
4749 reinterpret_cast<const VkImageSubresourceRange *>( ranges.data() ) );
4750 }
4751 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4752
4753 // wrapper function for command vkCmdDispatch, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatch.html
4754 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
4755 VULKAN_HPP_INLINE void
4756 CommandBuffer::dispatch( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
4757 {
4758 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
4759 d.vkCmdDispatch( static_cast<VkCommandBuffer>( m_commandBuffer ), groupCountX, groupCountY, groupCountZ );
4760 }
4761
4762 // wrapper function for command vkCmdDispatchIndirect, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchIndirect.html
4763 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
4764 VULKAN_HPP_INLINE void CommandBuffer::dispatchIndirect( Buffer buffer, DeviceSize offset, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
4765 {
4766 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
4767 d.vkCmdDispatchIndirect( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ) );
4768 }
4769
4770 // wrapper function for command vkCmdSetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetEvent.html
4771 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
4772 VULKAN_HPP_INLINE void CommandBuffer::setEvent( Event event, PipelineStageFlags stageMask, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
4773 {
4774 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
4775 d.vkCmdSetEvent( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkEvent>( event ), static_cast<VkPipelineStageFlags>( stageMask ) );
4776 }
4777
4778 // wrapper function for command vkCmdResetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResetEvent.html
4779 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
4780 VULKAN_HPP_INLINE void CommandBuffer::resetEvent( Event event, PipelineStageFlags stageMask, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
4781 {
4782 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
4783 d.vkCmdResetEvent( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkEvent>( event ), static_cast<VkPipelineStageFlags>( stageMask ) );
4784 }
4785
4786 // wrapper function for command vkCmdWaitEvents, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWaitEvents.html
4787 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
4788 VULKAN_HPP_INLINE void CommandBuffer::waitEvents( uint32_t eventCount,
4789 const Event * pEvents,
4790 PipelineStageFlags srcStageMask,
4791 PipelineStageFlags dstStageMask,
4792 uint32_t memoryBarrierCount,
4793 const MemoryBarrier * pMemoryBarriers,
4794 uint32_t bufferMemoryBarrierCount,
4795 const BufferMemoryBarrier * pBufferMemoryBarriers,
4796 uint32_t imageMemoryBarrierCount,
4797 const ImageMemoryBarrier * pImageMemoryBarriers,
4798 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
4799 {
4800 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
4801 d.vkCmdWaitEvents( static_cast<VkCommandBuffer>( m_commandBuffer ),
4802 eventCount,
4803 reinterpret_cast<const VkEvent *>( pEvents ),
4804 static_cast<VkPipelineStageFlags>( srcStageMask ),
4805 static_cast<VkPipelineStageFlags>( dstStageMask ),
4806 memoryBarrierCount,
4807 reinterpret_cast<const VkMemoryBarrier *>( pMemoryBarriers ),
4808 bufferMemoryBarrierCount,
4809 reinterpret_cast<const VkBufferMemoryBarrier *>( pBufferMemoryBarriers ),
4810 imageMemoryBarrierCount,
4811 reinterpret_cast<const VkImageMemoryBarrier *>( pImageMemoryBarriers ) );
4812 }
4813
4814 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4815 // wrapper function for command vkCmdWaitEvents, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWaitEvents.html
4816 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
4817 VULKAN_HPP_INLINE void CommandBuffer::waitEvents( ArrayProxy<const Event> const & events,
4818 PipelineStageFlags srcStageMask,
4819 PipelineStageFlags dstStageMask,
4820 ArrayProxy<const MemoryBarrier> const & memoryBarriers,
4821 ArrayProxy<const BufferMemoryBarrier> const & bufferMemoryBarriers,
4822 ArrayProxy<const ImageMemoryBarrier> const & imageMemoryBarriers,
4823 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
4824 {
4825 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
4826 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
4827 VULKAN_HPP_ASSERT( d.vkCmdWaitEvents && "Function <vkCmdWaitEvents> requires <VK_VERSION_1_0>" );
4828 # endif
4829
4830 d.vkCmdWaitEvents( m_commandBuffer,
4831 events.size(),
4832 reinterpret_cast<const VkEvent *>( events.data() ),
4833 static_cast<VkPipelineStageFlags>( srcStageMask ),
4834 static_cast<VkPipelineStageFlags>( dstStageMask ),
4835 memoryBarriers.size(),
4836 reinterpret_cast<const VkMemoryBarrier *>( memoryBarriers.data() ),
4837 bufferMemoryBarriers.size(),
4838 reinterpret_cast<const VkBufferMemoryBarrier *>( bufferMemoryBarriers.data() ),
4839 imageMemoryBarriers.size(),
4840 reinterpret_cast<const VkImageMemoryBarrier *>( imageMemoryBarriers.data() ) );
4841 }
4842 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4843
4844 // wrapper function for command vkCmdPushConstants, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushConstants.html
4845 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
4846 VULKAN_HPP_INLINE void CommandBuffer::pushConstants(
4847 PipelineLayout layout, ShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void * pValues, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
4848 {
4849 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
4850 d.vkCmdPushConstants( static_cast<VkCommandBuffer>( m_commandBuffer ),
4851 static_cast<VkPipelineLayout>( layout ),
4852 static_cast<VkShaderStageFlags>( stageFlags ),
4853 offset,
4854 size,
4855 pValues );
4856 }
4857
4858 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4859 // wrapper function for command vkCmdPushConstants, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushConstants.html
4860 template <typename ValuesType, typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
4861 VULKAN_HPP_INLINE void CommandBuffer::pushConstants( PipelineLayout layout,
4862 ShaderStageFlags stageFlags,
4863 uint32_t offset,
4864 ArrayProxy<const ValuesType> const & values,
4865 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
4866 {
4867 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
4868 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
4869 VULKAN_HPP_ASSERT( d.vkCmdPushConstants && "Function <vkCmdPushConstants> requires <VK_VERSION_1_0>" );
4870 # endif
4871
4872 d.vkCmdPushConstants( m_commandBuffer,
4873 static_cast<VkPipelineLayout>( layout ),
4874 static_cast<VkShaderStageFlags>( stageFlags ),
4875 offset,
4876 values.size() * sizeof( ValuesType ),
4877 reinterpret_cast<const void *>( values.data() ) );
4878 }
4879 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4880
4881 // wrapper function for command vkCreateGraphicsPipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGraphicsPipelines.html
4882 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
4883 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createGraphicsPipelines( PipelineCache pipelineCache,
4884 uint32_t createInfoCount,
4885 const GraphicsPipelineCreateInfo * pCreateInfos,
4886 const AllocationCallbacks * pAllocator,
4887 Pipeline * pPipelines,
4888 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
4889 {
4890 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
4891 return static_cast<Result>( d.vkCreateGraphicsPipelines( static_cast<VkDevice>( m_device ),
4892 static_cast<VkPipelineCache>( pipelineCache ),
4893 createInfoCount,
4894 reinterpret_cast<const VkGraphicsPipelineCreateInfo *>( pCreateInfos ),
4895 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
4896 reinterpret_cast<VkPipeline *>( pPipelines ) ) );
4897 }
4898
4899 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4900 // wrapper function for command vkCreateGraphicsPipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGraphicsPipelines.html
4901 template <typename PipelineAllocator,
4902 typename Dispatch,
4903 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, Pipeline>::value, int>::type,
4904 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
4905 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<Pipeline, PipelineAllocator>>
4906 Device::createGraphicsPipelines( PipelineCache pipelineCache,
4907 ArrayProxy<const GraphicsPipelineCreateInfo> const & createInfos,
4908 Optional<const AllocationCallbacks> allocator,
4909 Dispatch const & d ) const
4910 {
4911 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
4912 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
4913 VULKAN_HPP_ASSERT( d.vkCreateGraphicsPipelines && "Function <vkCreateGraphicsPipelines> requires <VK_VERSION_1_0>" );
4914 # endif
4915
4916 std::vector<Pipeline, PipelineAllocator> pipelines( createInfos.size() );
4917 Result result = static_cast<Result>( d.vkCreateGraphicsPipelines( m_device,
4918 static_cast<VkPipelineCache>( pipelineCache ),
4919 createInfos.size(),
4920 reinterpret_cast<const VkGraphicsPipelineCreateInfo *>( createInfos.data() ),
4921 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
4922 reinterpret_cast<VkPipeline *>( pipelines.data() ) ) );
4923 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelines", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } );
4924
4925 return ResultValue<std::vector<Pipeline, PipelineAllocator>>( result, std::move( pipelines ) );
4926 }
4927
4928 // wrapper function for command vkCreateGraphicsPipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGraphicsPipelines.html
4929 template <typename PipelineAllocator,
4930 typename Dispatch,
4931 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, Pipeline>::value, int>::type,
4932 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
4933 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<Pipeline, PipelineAllocator>>
4934 Device::createGraphicsPipelines( PipelineCache pipelineCache,
4935 ArrayProxy<const GraphicsPipelineCreateInfo> const & createInfos,
4936 Optional<const AllocationCallbacks> allocator,
4937 PipelineAllocator & pipelineAllocator,
4938 Dispatch const & d ) const
4939 {
4940 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
4941 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
4942 VULKAN_HPP_ASSERT( d.vkCreateGraphicsPipelines && "Function <vkCreateGraphicsPipelines> requires <VK_VERSION_1_0>" );
4943 # endif
4944
4945 std::vector<Pipeline, PipelineAllocator> pipelines( createInfos.size(), pipelineAllocator );
4946 Result result = static_cast<Result>( d.vkCreateGraphicsPipelines( m_device,
4947 static_cast<VkPipelineCache>( pipelineCache ),
4948 createInfos.size(),
4949 reinterpret_cast<const VkGraphicsPipelineCreateInfo *>( createInfos.data() ),
4950 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
4951 reinterpret_cast<VkPipeline *>( pipelines.data() ) ) );
4952 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelines", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } );
4953
4954 return ResultValue<std::vector<Pipeline, PipelineAllocator>>( result, std::move( pipelines ) );
4955 }
4956
4957 // wrapper function for command vkCreateGraphicsPipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGraphicsPipelines.html
4958 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
4959 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<Pipeline> Device::createGraphicsPipeline( PipelineCache pipelineCache,
4960 const GraphicsPipelineCreateInfo & createInfo,
4961 Optional<const AllocationCallbacks> allocator,
4962 Dispatch const & d ) const
4963 {
4964 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
4965 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
4966 VULKAN_HPP_ASSERT( d.vkCreateGraphicsPipelines && "Function <vkCreateGraphicsPipelines> requires <VK_VERSION_1_0>" );
4967 # endif
4968
4969 Pipeline pipeline;
4970 Result result = static_cast<Result>( d.vkCreateGraphicsPipelines( m_device,
4971 static_cast<VkPipelineCache>( pipelineCache ),
4972 1,
4973 reinterpret_cast<const VkGraphicsPipelineCreateInfo *>( &createInfo ),
4974 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
4975 reinterpret_cast<VkPipeline *>( &pipeline ) ) );
4976 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipeline", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } );
4977
4978 return ResultValue<Pipeline>( result, std::move( pipeline ) );
4979 }
4980
4981 # ifndef VULKAN_HPP_NO_SMART_HANDLE
4982 // wrapper function for command vkCreateGraphicsPipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGraphicsPipelines.html
4983 template <typename Dispatch,
4984 typename PipelineAllocator,
4985 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<Pipeline, Dispatch>>::value, int>::type,
4986 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
4987 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
4988 Device::createGraphicsPipelinesUnique( PipelineCache pipelineCache,
4989 ArrayProxy<const GraphicsPipelineCreateInfo> const & createInfos,
4990 Optional<const AllocationCallbacks> allocator,
4991 Dispatch const & d ) const
4992 {
4993 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
4994 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
4995 VULKAN_HPP_ASSERT( d.vkCreateGraphicsPipelines && "Function <vkCreateGraphicsPipelines> requires <VK_VERSION_1_0>" );
4996 # endif
4997
4998 std::vector<Pipeline> pipelines( createInfos.size() );
4999 Result result = static_cast<Result>( d.vkCreateGraphicsPipelines( m_device,
5000 static_cast<VkPipelineCache>( pipelineCache ),
5001 createInfos.size(),
5002 reinterpret_cast<const VkGraphicsPipelineCreateInfo *>( createInfos.data() ),
5003 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
5004 reinterpret_cast<VkPipeline *>( pipelines.data() ) ) );
5005 detail::resultCheck(
5006 result, VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelinesUnique", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } );
5007 std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator> uniquePipelines;
5008 uniquePipelines.reserve( createInfos.size() );
5009 detail::ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
5010 for ( auto const & pipeline : pipelines )
5011 {
5012 uniquePipelines.push_back( UniqueHandle<Pipeline, Dispatch>( pipeline, deleter ) );
5013 }
5014 return ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>( result, std::move( uniquePipelines ) );
5015 }
5016
5017 // wrapper function for command vkCreateGraphicsPipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGraphicsPipelines.html
5018 template <typename Dispatch,
5019 typename PipelineAllocator,
5020 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<Pipeline, Dispatch>>::value, int>::type,
5021 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
5022 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
5023 Device::createGraphicsPipelinesUnique( PipelineCache pipelineCache,
5024 ArrayProxy<const GraphicsPipelineCreateInfo> const & createInfos,
5025 Optional<const AllocationCallbacks> allocator,
5026 PipelineAllocator & pipelineAllocator,
5027 Dispatch const & d ) const
5028 {
5029 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
5030 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
5031 VULKAN_HPP_ASSERT( d.vkCreateGraphicsPipelines && "Function <vkCreateGraphicsPipelines> requires <VK_VERSION_1_0>" );
5032 # endif
5033
5034 std::vector<Pipeline> pipelines( createInfos.size() );
5035 Result result = static_cast<Result>( d.vkCreateGraphicsPipelines( m_device,
5036 static_cast<VkPipelineCache>( pipelineCache ),
5037 createInfos.size(),
5038 reinterpret_cast<const VkGraphicsPipelineCreateInfo *>( createInfos.data() ),
5039 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
5040 reinterpret_cast<VkPipeline *>( pipelines.data() ) ) );
5041 detail::resultCheck(
5042 result, VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelinesUnique", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } );
5043 std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator> uniquePipelines( pipelineAllocator );
5044 uniquePipelines.reserve( createInfos.size() );
5045 detail::ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
5046 for ( auto const & pipeline : pipelines )
5047 {
5048 uniquePipelines.push_back( UniqueHandle<Pipeline, Dispatch>( pipeline, deleter ) );
5049 }
5050 return ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>( result, std::move( uniquePipelines ) );
5051 }
5052
5053 // wrapper function for command vkCreateGraphicsPipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGraphicsPipelines.html
5054 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
5055 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<UniqueHandle<Pipeline, Dispatch>> Device::createGraphicsPipelineUnique(
5056 PipelineCache pipelineCache, const GraphicsPipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
5057 {
5058 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
5059 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
5060 VULKAN_HPP_ASSERT( d.vkCreateGraphicsPipelines && "Function <vkCreateGraphicsPipelines> requires <VK_VERSION_1_0>" );
5061 # endif
5062
5063 Pipeline pipeline;
5064 Result result = static_cast<Result>( d.vkCreateGraphicsPipelines( m_device,
5065 static_cast<VkPipelineCache>( pipelineCache ),
5066 1,
5067 reinterpret_cast<const VkGraphicsPipelineCreateInfo *>( &createInfo ),
5068 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
5069 reinterpret_cast<VkPipeline *>( &pipeline ) ) );
5070 detail::resultCheck(
5071 result, VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelineUnique", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } );
5072
5073 return ResultValue<UniqueHandle<Pipeline, Dispatch>>(
5074 result, UniqueHandle<Pipeline, Dispatch>( pipeline, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
5075 }
5076 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
5077 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5078
5079 // wrapper function for command vkCreateFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateFramebuffer.html
5080 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
5081 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createFramebuffer( const FramebufferCreateInfo * pCreateInfo,
5082 const AllocationCallbacks * pAllocator,
5083 Framebuffer * pFramebuffer,
5084 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
5085 {
5086 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
5087 return static_cast<Result>( d.vkCreateFramebuffer( static_cast<VkDevice>( m_device ),
5088 reinterpret_cast<const VkFramebufferCreateInfo *>( pCreateInfo ),
5089 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
5090 reinterpret_cast<VkFramebuffer *>( pFramebuffer ) ) );
5091 }
5092
5093 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5094 // wrapper function for command vkCreateFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateFramebuffer.html
5095 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
5096 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<Framebuffer>::type
5097 Device::createFramebuffer( const FramebufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
5098 {
5099 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
5100 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
5101 VULKAN_HPP_ASSERT( d.vkCreateFramebuffer && "Function <vkCreateFramebuffer> requires <VK_VERSION_1_0>" );
5102 # endif
5103
5104 Framebuffer framebuffer;
5105 Result result = static_cast<Result>( d.vkCreateFramebuffer( m_device,
5106 reinterpret_cast<const VkFramebufferCreateInfo *>( &createInfo ),
5107 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
5108 reinterpret_cast<VkFramebuffer *>( &framebuffer ) ) );
5109 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createFramebuffer" );
5110
5111 return detail::createResultValueType( result, std::move( framebuffer ) );
5112 }
5113
5114 # ifndef VULKAN_HPP_NO_SMART_HANDLE
5115 // wrapper function for command vkCreateFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateFramebuffer.html
5116 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
5117 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Framebuffer, Dispatch>>::type
5118 Device::createFramebufferUnique( const FramebufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
5119 {
5120 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
5121 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
5122 VULKAN_HPP_ASSERT( d.vkCreateFramebuffer && "Function <vkCreateFramebuffer> requires <VK_VERSION_1_0>" );
5123 # endif
5124
5125 Framebuffer framebuffer;
5126 Result result = static_cast<Result>( d.vkCreateFramebuffer( m_device,
5127 reinterpret_cast<const VkFramebufferCreateInfo *>( &createInfo ),
5128 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
5129 reinterpret_cast<VkFramebuffer *>( &framebuffer ) ) );
5130 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createFramebufferUnique" );
5131
5132 return detail::createResultValueType( result,
5133 UniqueHandle<Framebuffer, Dispatch>( framebuffer, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
5134 }
5135 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
5136 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5137
5138 // wrapper function for command vkDestroyFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyFramebuffer.html
5139 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
5140 VULKAN_HPP_INLINE void
5141 Device::destroyFramebuffer( Framebuffer framebuffer, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
5142 {
5143 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
5144 d.vkDestroyFramebuffer(
5145 static_cast<VkDevice>( m_device ), static_cast<VkFramebuffer>( framebuffer ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
5146 }
5147
5148 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5149 // wrapper function for command vkDestroyFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyFramebuffer.html
5150 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
5151 VULKAN_HPP_INLINE void
5152 Device::destroyFramebuffer( Framebuffer framebuffer, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
5153 {
5154 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
5155 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
5156 VULKAN_HPP_ASSERT( d.vkDestroyFramebuffer && "Function <vkDestroyFramebuffer> requires <VK_VERSION_1_0>" );
5157 # endif
5158
5159 d.vkDestroyFramebuffer( m_device, static_cast<VkFramebuffer>( framebuffer ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
5160 }
5161 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5162
5163 // wrapper function for command vkDestroyFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyFramebuffer.html
5164 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
5165 VULKAN_HPP_INLINE void Device::destroy( Framebuffer framebuffer, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
5166 {
5167 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
5168 d.vkDestroyFramebuffer(
5169 static_cast<VkDevice>( m_device ), static_cast<VkFramebuffer>( framebuffer ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
5170 }
5171
5172 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5173 // wrapper function for command vkDestroyFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyFramebuffer.html
5174 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
5175 VULKAN_HPP_INLINE void Device::destroy( Framebuffer framebuffer, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
5176 {
5177 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
5178 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
5179 VULKAN_HPP_ASSERT( d.vkDestroyFramebuffer && "Function <vkDestroyFramebuffer> requires <VK_VERSION_1_0>" );
5180 # endif
5181
5182 d.vkDestroyFramebuffer( m_device, static_cast<VkFramebuffer>( framebuffer ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
5183 }
5184 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5185
5186 // wrapper function for command vkCreateRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass.html
5187 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
5188 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createRenderPass( const RenderPassCreateInfo * pCreateInfo,
5189 const AllocationCallbacks * pAllocator,
5190 RenderPass * pRenderPass,
5191 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
5192 {
5193 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
5194 return static_cast<Result>( d.vkCreateRenderPass( static_cast<VkDevice>( m_device ),
5195 reinterpret_cast<const VkRenderPassCreateInfo *>( pCreateInfo ),
5196 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
5197 reinterpret_cast<VkRenderPass *>( pRenderPass ) ) );
5198 }
5199
5200 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5201 // wrapper function for command vkCreateRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass.html
5202 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
5203 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<RenderPass>::type
5204 Device::createRenderPass( const RenderPassCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
5205 {
5206 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
5207 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
5208 VULKAN_HPP_ASSERT( d.vkCreateRenderPass && "Function <vkCreateRenderPass> requires <VK_VERSION_1_0>" );
5209 # endif
5210
5211 RenderPass renderPass;
5212 Result result = static_cast<Result>( d.vkCreateRenderPass( m_device,
5213 reinterpret_cast<const VkRenderPassCreateInfo *>( &createInfo ),
5214 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
5215 reinterpret_cast<VkRenderPass *>( &renderPass ) ) );
5216 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPass" );
5217
5218 return detail::createResultValueType( result, std::move( renderPass ) );
5219 }
5220
5221 # ifndef VULKAN_HPP_NO_SMART_HANDLE
5222 // wrapper function for command vkCreateRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass.html
5223 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
5224 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<RenderPass, Dispatch>>::type
5225 Device::createRenderPassUnique( const RenderPassCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
5226 {
5227 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
5228 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
5229 VULKAN_HPP_ASSERT( d.vkCreateRenderPass && "Function <vkCreateRenderPass> requires <VK_VERSION_1_0>" );
5230 # endif
5231
5232 RenderPass renderPass;
5233 Result result = static_cast<Result>( d.vkCreateRenderPass( m_device,
5234 reinterpret_cast<const VkRenderPassCreateInfo *>( &createInfo ),
5235 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
5236 reinterpret_cast<VkRenderPass *>( &renderPass ) ) );
5237 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPassUnique" );
5238
5239 return detail::createResultValueType( result,
5240 UniqueHandle<RenderPass, Dispatch>( renderPass, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
5241 }
5242 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
5243 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5244
5245 // wrapper function for command vkDestroyRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyRenderPass.html
5246 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
5247 VULKAN_HPP_INLINE void
5248 Device::destroyRenderPass( RenderPass renderPass, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
5249 {
5250 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
5251 d.vkDestroyRenderPass(
5252 static_cast<VkDevice>( m_device ), static_cast<VkRenderPass>( renderPass ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
5253 }
5254
5255 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5256 // wrapper function for command vkDestroyRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyRenderPass.html
5257 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
5258 VULKAN_HPP_INLINE void
5259 Device::destroyRenderPass( RenderPass renderPass, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
5260 {
5261 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
5262 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
5263 VULKAN_HPP_ASSERT( d.vkDestroyRenderPass && "Function <vkDestroyRenderPass> requires <VK_VERSION_1_0>" );
5264 # endif
5265
5266 d.vkDestroyRenderPass( m_device, static_cast<VkRenderPass>( renderPass ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
5267 }
5268 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5269
5270 // wrapper function for command vkDestroyRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyRenderPass.html
5271 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
5272 VULKAN_HPP_INLINE void Device::destroy( RenderPass renderPass, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
5273 {
5274 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
5275 d.vkDestroyRenderPass(
5276 static_cast<VkDevice>( m_device ), static_cast<VkRenderPass>( renderPass ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
5277 }
5278
5279 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5280 // wrapper function for command vkDestroyRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyRenderPass.html
5281 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
5282 VULKAN_HPP_INLINE void Device::destroy( RenderPass renderPass, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
5283 {
5284 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
5285 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
5286 VULKAN_HPP_ASSERT( d.vkDestroyRenderPass && "Function <vkDestroyRenderPass> requires <VK_VERSION_1_0>" );
5287 # endif
5288
5289 d.vkDestroyRenderPass( m_device, static_cast<VkRenderPass>( renderPass ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
5290 }
5291 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5292
5293 // wrapper function for command vkGetRenderAreaGranularity, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRenderAreaGranularity.html
5294 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
5295 VULKAN_HPP_INLINE void Device::getRenderAreaGranularity( RenderPass renderPass, Extent2D * pGranularity, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
5296 {
5297 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
5298 d.vkGetRenderAreaGranularity( static_cast<VkDevice>( m_device ), static_cast<VkRenderPass>( renderPass ), reinterpret_cast<VkExtent2D *>( pGranularity ) );
5299 }
5300
5301 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5302 // wrapper function for command vkGetRenderAreaGranularity, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRenderAreaGranularity.html
5303 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
5304 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Extent2D Device::getRenderAreaGranularity( RenderPass renderPass, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
5305 {
5306 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
5307 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
5308 VULKAN_HPP_ASSERT( d.vkGetRenderAreaGranularity && "Function <vkGetRenderAreaGranularity> requires <VK_VERSION_1_0>" );
5309 # endif
5310
5311 Extent2D granularity;
5312 d.vkGetRenderAreaGranularity( m_device, static_cast<VkRenderPass>( renderPass ), reinterpret_cast<VkExtent2D *>( &granularity ) );
5313
5314 return granularity;
5315 }
5316 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5317
5318 // wrapper function for command vkCmdSetViewport, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewport.html
5319 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
5320 VULKAN_HPP_INLINE void
5321 CommandBuffer::setViewport( uint32_t firstViewport, uint32_t viewportCount, const Viewport * pViewports, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
5322 {
5323 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
5324 d.vkCmdSetViewport( static_cast<VkCommandBuffer>( m_commandBuffer ), firstViewport, viewportCount, reinterpret_cast<const VkViewport *>( pViewports ) );
5325 }
5326
5327 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5328 // wrapper function for command vkCmdSetViewport, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewport.html
5329 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
5330 VULKAN_HPP_INLINE void
5331 CommandBuffer::setViewport( uint32_t firstViewport, ArrayProxy<const Viewport> const & viewports, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
5332 {
5333 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
5334 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
5335 VULKAN_HPP_ASSERT( d.vkCmdSetViewport && "Function <vkCmdSetViewport> requires <VK_VERSION_1_0>" );
5336 # endif
5337
5338 d.vkCmdSetViewport( m_commandBuffer, firstViewport, viewports.size(), reinterpret_cast<const VkViewport *>( viewports.data() ) );
5339 }
5340 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5341
5342 // wrapper function for command vkCmdSetScissor, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetScissor.html
5343 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
5344 VULKAN_HPP_INLINE void
5345 CommandBuffer::setScissor( uint32_t firstScissor, uint32_t scissorCount, const Rect2D * pScissors, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
5346 {
5347 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
5348 d.vkCmdSetScissor( static_cast<VkCommandBuffer>( m_commandBuffer ), firstScissor, scissorCount, reinterpret_cast<const VkRect2D *>( pScissors ) );
5349 }
5350
5351 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5352 // wrapper function for command vkCmdSetScissor, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetScissor.html
5353 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
5354 VULKAN_HPP_INLINE void
5355 CommandBuffer::setScissor( uint32_t firstScissor, ArrayProxy<const Rect2D> const & scissors, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
5356 {
5357 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
5358 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
5359 VULKAN_HPP_ASSERT( d.vkCmdSetScissor && "Function <vkCmdSetScissor> requires <VK_VERSION_1_0>" );
5360 # endif
5361
5362 d.vkCmdSetScissor( m_commandBuffer, firstScissor, scissors.size(), reinterpret_cast<const VkRect2D *>( scissors.data() ) );
5363 }
5364 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5365
5366 // wrapper function for command vkCmdSetLineWidth, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineWidth.html
5367 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
5368 VULKAN_HPP_INLINE void CommandBuffer::setLineWidth( float lineWidth, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
5369 {
5370 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
5371 d.vkCmdSetLineWidth( static_cast<VkCommandBuffer>( m_commandBuffer ), lineWidth );
5372 }
5373
5374 // wrapper function for command vkCmdSetDepthBias, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBias.html
5375 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
5376 VULKAN_HPP_INLINE void
5377 CommandBuffer::setDepthBias( float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
5378 {
5379 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
5380 d.vkCmdSetDepthBias( static_cast<VkCommandBuffer>( m_commandBuffer ), depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor );
5381 }
5382
5383 // wrapper function for command vkCmdSetBlendConstants, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetBlendConstants.html
5384 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
5385 VULKAN_HPP_INLINE void CommandBuffer::setBlendConstants( const float blendConstants[4], Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
5386 {
5387 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
5388 d.vkCmdSetBlendConstants( static_cast<VkCommandBuffer>( m_commandBuffer ), blendConstants );
5389 }
5390
5391 // wrapper function for command vkCmdSetDepthBounds, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBounds.html
5392 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
5393 VULKAN_HPP_INLINE void CommandBuffer::setDepthBounds( float minDepthBounds, float maxDepthBounds, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
5394 {
5395 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
5396 d.vkCmdSetDepthBounds( static_cast<VkCommandBuffer>( m_commandBuffer ), minDepthBounds, maxDepthBounds );
5397 }
5398
5399 // wrapper function for command vkCmdSetStencilCompareMask, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilCompareMask.html
5400 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
5401 VULKAN_HPP_INLINE void CommandBuffer::setStencilCompareMask( StencilFaceFlags faceMask, uint32_t compareMask, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
5402 {
5403 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
5404 d.vkCmdSetStencilCompareMask( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkStencilFaceFlags>( faceMask ), compareMask );
5405 }
5406
5407 // wrapper function for command vkCmdSetStencilWriteMask, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilWriteMask.html
5408 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
5409 VULKAN_HPP_INLINE void CommandBuffer::setStencilWriteMask( StencilFaceFlags faceMask, uint32_t writeMask, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
5410 {
5411 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
5412 d.vkCmdSetStencilWriteMask( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkStencilFaceFlags>( faceMask ), writeMask );
5413 }
5414
5415 // wrapper function for command vkCmdSetStencilReference, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilReference.html
5416 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
5417 VULKAN_HPP_INLINE void CommandBuffer::setStencilReference( StencilFaceFlags faceMask, uint32_t reference, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
5418 {
5419 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
5420 d.vkCmdSetStencilReference( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkStencilFaceFlags>( faceMask ), reference );
5421 }
5422
5423 // wrapper function for command vkCmdBindIndexBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindIndexBuffer.html
5424 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
5425 VULKAN_HPP_INLINE void CommandBuffer::bindIndexBuffer( Buffer buffer, DeviceSize offset, IndexType indexType, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
5426 {
5427 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
5428 d.vkCmdBindIndexBuffer( static_cast<VkCommandBuffer>( m_commandBuffer ),
5429 static_cast<VkBuffer>( buffer ),
5430 static_cast<VkDeviceSize>( offset ),
5431 static_cast<VkIndexType>( indexType ) );
5432 }
5433
5434 // wrapper function for command vkCmdBindVertexBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers.html
5435 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
5436 VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers(
5437 uint32_t firstBinding, uint32_t bindingCount, const Buffer * pBuffers, const DeviceSize * pOffsets, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
5438 {
5439 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
5440 d.vkCmdBindVertexBuffers( static_cast<VkCommandBuffer>( m_commandBuffer ),
5441 firstBinding,
5442 bindingCount,
5443 reinterpret_cast<const VkBuffer *>( pBuffers ),
5444 reinterpret_cast<const VkDeviceSize *>( pOffsets ) );
5445 }
5446
5447 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5448 // wrapper function for command vkCmdBindVertexBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers.html
5449 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
5450 VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers( uint32_t firstBinding,
5451 ArrayProxy<const Buffer> const & buffers,
5452 ArrayProxy<const DeviceSize> const & offsets,
5453 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
5454 {
5455 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
5456 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
5457 VULKAN_HPP_ASSERT( d.vkCmdBindVertexBuffers && "Function <vkCmdBindVertexBuffers> requires <VK_VERSION_1_0>" );
5458 # endif
5459 # ifdef VULKAN_HPP_NO_EXCEPTIONS
5460 VULKAN_HPP_ASSERT( buffers.size() == offsets.size() );
5461 # else
5462 if ( buffers.size() != offsets.size() )
5463 {
5464 throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers: buffers.size() != offsets.size()" );
5465 }
5466 # endif /*VULKAN_HPP_NO_EXCEPTIONS*/
5467
5468 d.vkCmdBindVertexBuffers( m_commandBuffer,
5469 firstBinding,
5470 buffers.size(),
5471 reinterpret_cast<const VkBuffer *>( buffers.data() ),
5472 reinterpret_cast<const VkDeviceSize *>( offsets.data() ) );
5473 }
5474 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5475
5476 // wrapper function for command vkCmdDraw, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDraw.html
5477 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
5478 VULKAN_HPP_INLINE void CommandBuffer::draw(
5479 uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
5480 {
5481 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
5482 d.vkCmdDraw( static_cast<VkCommandBuffer>( m_commandBuffer ), vertexCount, instanceCount, firstVertex, firstInstance );
5483 }
5484
5485 // wrapper function for command vkCmdDrawIndexed, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexed.html
5486 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
5487 VULKAN_HPP_INLINE void CommandBuffer::drawIndexed( uint32_t indexCount,
5488 uint32_t instanceCount,
5489 uint32_t firstIndex,
5490 int32_t vertexOffset,
5491 uint32_t firstInstance,
5492 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
5493 {
5494 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
5495 d.vkCmdDrawIndexed( static_cast<VkCommandBuffer>( m_commandBuffer ), indexCount, instanceCount, firstIndex, vertexOffset, firstInstance );
5496 }
5497
5498 // wrapper function for command vkCmdDrawIndirect, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirect.html
5499 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
5500 VULKAN_HPP_INLINE void
5501 CommandBuffer::drawIndirect( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
5502 {
5503 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
5504 d.vkCmdDrawIndirect(
5505 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), drawCount, stride );
5506 }
5507
5508 // wrapper function for command vkCmdDrawIndexedIndirect, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexedIndirect.html
5509 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
5510 VULKAN_HPP_INLINE void
5511 CommandBuffer::drawIndexedIndirect( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
5512 {
5513 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
5514 d.vkCmdDrawIndexedIndirect(
5515 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), drawCount, stride );
5516 }
5517
5518 // wrapper function for command vkCmdBlitImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBlitImage.html
5519 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
5520 VULKAN_HPP_INLINE void CommandBuffer::blitImage( Image srcImage,
5521 ImageLayout srcImageLayout,
5522 Image dstImage,
5523 ImageLayout dstImageLayout,
5524 uint32_t regionCount,
5525 const ImageBlit * pRegions,
5526 Filter filter,
5527 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
5528 {
5529 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
5530 d.vkCmdBlitImage( static_cast<VkCommandBuffer>( m_commandBuffer ),
5531 static_cast<VkImage>( srcImage ),
5532 static_cast<VkImageLayout>( srcImageLayout ),
5533 static_cast<VkImage>( dstImage ),
5534 static_cast<VkImageLayout>( dstImageLayout ),
5535 regionCount,
5536 reinterpret_cast<const VkImageBlit *>( pRegions ),
5537 static_cast<VkFilter>( filter ) );
5538 }
5539
5540 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5541 // wrapper function for command vkCmdBlitImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBlitImage.html
5542 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
5543 VULKAN_HPP_INLINE void CommandBuffer::blitImage( Image srcImage,
5544 ImageLayout srcImageLayout,
5545 Image dstImage,
5546 ImageLayout dstImageLayout,
5547 ArrayProxy<const ImageBlit> const & regions,
5548 Filter filter,
5549 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
5550 {
5551 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
5552 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
5553 VULKAN_HPP_ASSERT( d.vkCmdBlitImage && "Function <vkCmdBlitImage> requires <VK_VERSION_1_0>" );
5554 # endif
5555
5556 d.vkCmdBlitImage( m_commandBuffer,
5557 static_cast<VkImage>( srcImage ),
5558 static_cast<VkImageLayout>( srcImageLayout ),
5559 static_cast<VkImage>( dstImage ),
5560 static_cast<VkImageLayout>( dstImageLayout ),
5561 regions.size(),
5562 reinterpret_cast<const VkImageBlit *>( regions.data() ),
5563 static_cast<VkFilter>( filter ) );
5564 }
5565 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5566
5567 // wrapper function for command vkCmdClearDepthStencilImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdClearDepthStencilImage.html
5568 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
5569 VULKAN_HPP_INLINE void CommandBuffer::clearDepthStencilImage( Image image,
5570 ImageLayout imageLayout,
5571 const ClearDepthStencilValue * pDepthStencil,
5572 uint32_t rangeCount,
5573 const ImageSubresourceRange * pRanges,
5574 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
5575 {
5576 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
5577 d.vkCmdClearDepthStencilImage( static_cast<VkCommandBuffer>( m_commandBuffer ),
5578 static_cast<VkImage>( image ),
5579 static_cast<VkImageLayout>( imageLayout ),
5580 reinterpret_cast<const VkClearDepthStencilValue *>( pDepthStencil ),
5581 rangeCount,
5582 reinterpret_cast<const VkImageSubresourceRange *>( pRanges ) );
5583 }
5584
5585 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5586 // wrapper function for command vkCmdClearDepthStencilImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdClearDepthStencilImage.html
5587 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
5588 VULKAN_HPP_INLINE void CommandBuffer::clearDepthStencilImage( Image image,
5589 ImageLayout imageLayout,
5590 const ClearDepthStencilValue & depthStencil,
5591 ArrayProxy<const ImageSubresourceRange> const & ranges,
5592 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
5593 {
5594 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
5595 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
5596 VULKAN_HPP_ASSERT( d.vkCmdClearDepthStencilImage && "Function <vkCmdClearDepthStencilImage> requires <VK_VERSION_1_0>" );
5597 # endif
5598
5599 d.vkCmdClearDepthStencilImage( m_commandBuffer,
5600 static_cast<VkImage>( image ),
5601 static_cast<VkImageLayout>( imageLayout ),
5602 reinterpret_cast<const VkClearDepthStencilValue *>( &depthStencil ),
5603 ranges.size(),
5604 reinterpret_cast<const VkImageSubresourceRange *>( ranges.data() ) );
5605 }
5606 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5607
5608 // wrapper function for command vkCmdClearAttachments, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdClearAttachments.html
5609 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
5610 VULKAN_HPP_INLINE void CommandBuffer::clearAttachments(
5611 uint32_t attachmentCount, const ClearAttachment * pAttachments, uint32_t rectCount, const ClearRect * pRects, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
5612 {
5613 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
5614 d.vkCmdClearAttachments( static_cast<VkCommandBuffer>( m_commandBuffer ),
5615 attachmentCount,
5616 reinterpret_cast<const VkClearAttachment *>( pAttachments ),
5617 rectCount,
5618 reinterpret_cast<const VkClearRect *>( pRects ) );
5619 }
5620
5621 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5622 // wrapper function for command vkCmdClearAttachments, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdClearAttachments.html
5623 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
5624 VULKAN_HPP_INLINE void CommandBuffer::clearAttachments( ArrayProxy<const ClearAttachment> const & attachments,
5625 ArrayProxy<const ClearRect> const & rects,
5626 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
5627 {
5628 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
5629 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
5630 VULKAN_HPP_ASSERT( d.vkCmdClearAttachments && "Function <vkCmdClearAttachments> requires <VK_VERSION_1_0>" );
5631 # endif
5632
5633 d.vkCmdClearAttachments( m_commandBuffer,
5634 attachments.size(),
5635 reinterpret_cast<const VkClearAttachment *>( attachments.data() ),
5636 rects.size(),
5637 reinterpret_cast<const VkClearRect *>( rects.data() ) );
5638 }
5639 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5640
5641 // wrapper function for command vkCmdResolveImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResolveImage.html
5642 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
5643 VULKAN_HPP_INLINE void CommandBuffer::resolveImage( Image srcImage,
5644 ImageLayout srcImageLayout,
5645 Image dstImage,
5646 ImageLayout dstImageLayout,
5647 uint32_t regionCount,
5648 const ImageResolve * pRegions,
5649 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
5650 {
5651 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
5652 d.vkCmdResolveImage( static_cast<VkCommandBuffer>( m_commandBuffer ),
5653 static_cast<VkImage>( srcImage ),
5654 static_cast<VkImageLayout>( srcImageLayout ),
5655 static_cast<VkImage>( dstImage ),
5656 static_cast<VkImageLayout>( dstImageLayout ),
5657 regionCount,
5658 reinterpret_cast<const VkImageResolve *>( pRegions ) );
5659 }
5660
5661 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5662 // wrapper function for command vkCmdResolveImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResolveImage.html
5663 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
5664 VULKAN_HPP_INLINE void CommandBuffer::resolveImage( Image srcImage,
5665 ImageLayout srcImageLayout,
5666 Image dstImage,
5667 ImageLayout dstImageLayout,
5668 ArrayProxy<const ImageResolve> const & regions,
5669 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
5670 {
5671 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
5672 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
5673 VULKAN_HPP_ASSERT( d.vkCmdResolveImage && "Function <vkCmdResolveImage> requires <VK_VERSION_1_0>" );
5674 # endif
5675
5676 d.vkCmdResolveImage( m_commandBuffer,
5677 static_cast<VkImage>( srcImage ),
5678 static_cast<VkImageLayout>( srcImageLayout ),
5679 static_cast<VkImage>( dstImage ),
5680 static_cast<VkImageLayout>( dstImageLayout ),
5681 regions.size(),
5682 reinterpret_cast<const VkImageResolve *>( regions.data() ) );
5683 }
5684 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5685
5686 // wrapper function for command vkCmdBeginRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderPass.html
5687 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
5688 VULKAN_HPP_INLINE void
5689 CommandBuffer::beginRenderPass( const RenderPassBeginInfo * pRenderPassBegin, SubpassContents contents, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
5690 {
5691 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
5692 d.vkCmdBeginRenderPass( static_cast<VkCommandBuffer>( m_commandBuffer ),
5693 reinterpret_cast<const VkRenderPassBeginInfo *>( pRenderPassBegin ),
5694 static_cast<VkSubpassContents>( contents ) );
5695 }
5696
5697 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5698 // wrapper function for command vkCmdBeginRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderPass.html
5699 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
5700 VULKAN_HPP_INLINE void
5701 CommandBuffer::beginRenderPass( const RenderPassBeginInfo & renderPassBegin, SubpassContents contents, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
5702 {
5703 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
5704 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
5705 VULKAN_HPP_ASSERT( d.vkCmdBeginRenderPass && "Function <vkCmdBeginRenderPass> requires <VK_VERSION_1_0>" );
5706 # endif
5707
5708 d.vkCmdBeginRenderPass( m_commandBuffer, reinterpret_cast<const VkRenderPassBeginInfo *>( &renderPassBegin ), static_cast<VkSubpassContents>( contents ) );
5709 }
5710 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5711
5712 // wrapper function for command vkCmdNextSubpass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdNextSubpass.html
5713 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
5714 VULKAN_HPP_INLINE void CommandBuffer::nextSubpass( SubpassContents contents, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
5715 {
5716 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
5717 d.vkCmdNextSubpass( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkSubpassContents>( contents ) );
5718 }
5719
5720 // wrapper function for command vkCmdEndRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderPass.html
5721 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
5722 VULKAN_HPP_INLINE void CommandBuffer::endRenderPass( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
5723 {
5724 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
5725 d.vkCmdEndRenderPass( static_cast<VkCommandBuffer>( m_commandBuffer ) );
5726 }
5727
5728 //=== VK_VERSION_1_1 ===
5729
5730 // wrapper function for command vkEnumerateInstanceVersion, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceVersion.html
5731 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
5732 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result enumerateInstanceVersion( uint32_t * pApiVersion, Dispatch const & d ) VULKAN_HPP_NOEXCEPT
5733 {
5734 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
5735 return static_cast<Result>( d.vkEnumerateInstanceVersion( pApiVersion ) );
5736 }
5737
5738 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5739 // wrapper function for command vkEnumerateInstanceVersion, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceVersion.html
5740 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
5741 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<uint32_t>::type enumerateInstanceVersion( Dispatch const & d )
5742 {
5743 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
5744 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
5745 VULKAN_HPP_ASSERT( d.vkEnumerateInstanceVersion && "Function <vkEnumerateInstanceVersion> requires <VK_VERSION_1_1>" );
5746 # endif
5747
5748 uint32_t apiVersion;
5749 Result result = static_cast<Result>( d.vkEnumerateInstanceVersion( &apiVersion ) );
5750 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::enumerateInstanceVersion" );
5751
5752 return detail::createResultValueType( result, std::move( apiVersion ) );
5753 }
5754 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5755
5756 // wrapper function for command vkBindBufferMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindBufferMemory2.html
5757 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
5758 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::bindBufferMemory2( uint32_t bindInfoCount,
5759 const BindBufferMemoryInfo * pBindInfos,
5760 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
5761 {
5762 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
5763 return static_cast<Result>(
5764 d.vkBindBufferMemory2( static_cast<VkDevice>( m_device ), bindInfoCount, reinterpret_cast<const VkBindBufferMemoryInfo *>( pBindInfos ) ) );
5765 }
5766
5767 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5768 // wrapper function for command vkBindBufferMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindBufferMemory2.html
5769 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
5770 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
5771 Device::bindBufferMemory2( ArrayProxy<const BindBufferMemoryInfo> const & bindInfos, Dispatch const & d ) const
5772 {
5773 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
5774 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
5775 VULKAN_HPP_ASSERT( d.vkBindBufferMemory2 && "Function <vkBindBufferMemory2> requires <VK_KHR_bind_memory2> or <VK_VERSION_1_1>" );
5776 # endif
5777
5778 Result result =
5779 static_cast<Result>( d.vkBindBufferMemory2( m_device, bindInfos.size(), reinterpret_cast<const VkBindBufferMemoryInfo *>( bindInfos.data() ) ) );
5780 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindBufferMemory2" );
5781
5782 return detail::createResultValueType( result );
5783 }
5784 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5785
5786 // wrapper function for command vkBindImageMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindImageMemory2.html
5787 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
5788 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::bindImageMemory2( uint32_t bindInfoCount,
5789 const BindImageMemoryInfo * pBindInfos,
5790 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
5791 {
5792 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
5793 return static_cast<Result>(
5794 d.vkBindImageMemory2( static_cast<VkDevice>( m_device ), bindInfoCount, reinterpret_cast<const VkBindImageMemoryInfo *>( pBindInfos ) ) );
5795 }
5796
5797 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5798 // wrapper function for command vkBindImageMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindImageMemory2.html
5799 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
5800 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
5801 Device::bindImageMemory2( ArrayProxy<const BindImageMemoryInfo> const & bindInfos, Dispatch const & d ) const
5802 {
5803 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
5804 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
5805 VULKAN_HPP_ASSERT( d.vkBindImageMemory2 && "Function <vkBindImageMemory2> requires <VK_KHR_bind_memory2> or <VK_VERSION_1_1>" );
5806 # endif
5807
5808 Result result =
5809 static_cast<Result>( d.vkBindImageMemory2( m_device, bindInfos.size(), reinterpret_cast<const VkBindImageMemoryInfo *>( bindInfos.data() ) ) );
5810 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindImageMemory2" );
5811
5812 return detail::createResultValueType( result );
5813 }
5814 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5815
5816 // wrapper function for command vkGetDeviceGroupPeerMemoryFeatures, see
5817 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupPeerMemoryFeatures.html
5818 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
5819 VULKAN_HPP_INLINE void Device::getGroupPeerMemoryFeatures( uint32_t heapIndex,
5820 uint32_t localDeviceIndex,
5821 uint32_t remoteDeviceIndex,
5822 PeerMemoryFeatureFlags * pPeerMemoryFeatures,
5823 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
5824 {
5825 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
5826 d.vkGetDeviceGroupPeerMemoryFeatures(
5827 static_cast<VkDevice>( m_device ), heapIndex, localDeviceIndex, remoteDeviceIndex, reinterpret_cast<VkPeerMemoryFeatureFlags *>( pPeerMemoryFeatures ) );
5828 }
5829
5830 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5831 // wrapper function for command vkGetDeviceGroupPeerMemoryFeatures, see
5832 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupPeerMemoryFeatures.html
5833 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
5834 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PeerMemoryFeatureFlags Device::getGroupPeerMemoryFeatures( uint32_t heapIndex,
5835 uint32_t localDeviceIndex,
5836 uint32_t remoteDeviceIndex,
5837 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
5838 {
5839 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
5840 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
5841 VULKAN_HPP_ASSERT( d.vkGetDeviceGroupPeerMemoryFeatures &&
5842 "Function <vkGetDeviceGroupPeerMemoryFeatures> requires <VK_KHR_device_group> or <VK_VERSION_1_1>" );
5843 # endif
5844
5845 PeerMemoryFeatureFlags peerMemoryFeatures;
5846 d.vkGetDeviceGroupPeerMemoryFeatures(
5847 m_device, heapIndex, localDeviceIndex, remoteDeviceIndex, reinterpret_cast<VkPeerMemoryFeatureFlags *>( &peerMemoryFeatures ) );
5848
5849 return peerMemoryFeatures;
5850 }
5851 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5852
5853 // wrapper function for command vkCmdSetDeviceMask, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDeviceMask.html
5854 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
5855 VULKAN_HPP_INLINE void CommandBuffer::setDeviceMask( uint32_t deviceMask, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
5856 {
5857 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
5858 d.vkCmdSetDeviceMask( static_cast<VkCommandBuffer>( m_commandBuffer ), deviceMask );
5859 }
5860
5861 // wrapper function for command vkEnumeratePhysicalDeviceGroups, see
5862 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceGroups.html
5863 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
5864 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::enumeratePhysicalDeviceGroups( uint32_t * pPhysicalDeviceGroupCount,
5865 PhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties,
5866 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
5867 {
5868 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
5869 return static_cast<Result>( d.vkEnumeratePhysicalDeviceGroups( static_cast<VkInstance>( m_instance ),
5870 pPhysicalDeviceGroupCount,
5871 reinterpret_cast<VkPhysicalDeviceGroupProperties *>( pPhysicalDeviceGroupProperties ) ) );
5872 }
5873
5874 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5875 // wrapper function for command vkEnumeratePhysicalDeviceGroups, see
5876 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceGroups.html
5877 template <typename PhysicalDeviceGroupPropertiesAllocator,
5878 typename Dispatch,
5879 typename std::enable_if<std::is_same<typename PhysicalDeviceGroupPropertiesAllocator::value_type, PhysicalDeviceGroupProperties>::value, int>::type,
5880 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
5881 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type
5882 Instance::enumeratePhysicalDeviceGroups( Dispatch const & d ) const
5883 {
5884 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
5885 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
5886 VULKAN_HPP_ASSERT( d.vkEnumeratePhysicalDeviceGroups &&
5887 "Function <vkEnumeratePhysicalDeviceGroups> requires <VK_KHR_device_group_creation> or <VK_VERSION_1_1>" );
5888 # endif
5889
5890 std::vector<PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator> physicalDeviceGroupProperties;
5891 uint32_t physicalDeviceGroupCount;
5892 Result result;
5893 do
5894 {
5895 result = static_cast<Result>( d.vkEnumeratePhysicalDeviceGroups( m_instance, &physicalDeviceGroupCount, nullptr ) );
5896 if ( ( result == Result::eSuccess ) && physicalDeviceGroupCount )
5897 {
5898 physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
5899 result = static_cast<Result>( d.vkEnumeratePhysicalDeviceGroups(
5900 m_instance, &physicalDeviceGroupCount, reinterpret_cast<VkPhysicalDeviceGroupProperties *>( physicalDeviceGroupProperties.data() ) ) );
5901 }
5902 } while ( result == Result::eIncomplete );
5903 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::enumeratePhysicalDeviceGroups" );
5904 VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() );
5905 if ( physicalDeviceGroupCount < physicalDeviceGroupProperties.size() )
5906 {
5907 physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
5908 }
5909 return detail::createResultValueType( result, std::move( physicalDeviceGroupProperties ) );
5910 }
5911
5912 // wrapper function for command vkEnumeratePhysicalDeviceGroups, see
5913 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceGroups.html
5914 template <typename PhysicalDeviceGroupPropertiesAllocator,
5915 typename Dispatch,
5916 typename std::enable_if<std::is_same<typename PhysicalDeviceGroupPropertiesAllocator::value_type, PhysicalDeviceGroupProperties>::value, int>::type,
5917 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
5918 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type
5919 Instance::enumeratePhysicalDeviceGroups( PhysicalDeviceGroupPropertiesAllocator & physicalDeviceGroupPropertiesAllocator, Dispatch const & d ) const
5920 {
5921 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
5922 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
5923 VULKAN_HPP_ASSERT( d.vkEnumeratePhysicalDeviceGroups &&
5924 "Function <vkEnumeratePhysicalDeviceGroups> requires <VK_KHR_device_group_creation> or <VK_VERSION_1_1>" );
5925 # endif
5926
5927 std::vector<PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator> physicalDeviceGroupProperties( physicalDeviceGroupPropertiesAllocator );
5928 uint32_t physicalDeviceGroupCount;
5929 Result result;
5930 do
5931 {
5932 result = static_cast<Result>( d.vkEnumeratePhysicalDeviceGroups( m_instance, &physicalDeviceGroupCount, nullptr ) );
5933 if ( ( result == Result::eSuccess ) && physicalDeviceGroupCount )
5934 {
5935 physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
5936 result = static_cast<Result>( d.vkEnumeratePhysicalDeviceGroups(
5937 m_instance, &physicalDeviceGroupCount, reinterpret_cast<VkPhysicalDeviceGroupProperties *>( physicalDeviceGroupProperties.data() ) ) );
5938 }
5939 } while ( result == Result::eIncomplete );
5940 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::enumeratePhysicalDeviceGroups" );
5941 VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() );
5942 if ( physicalDeviceGroupCount < physicalDeviceGroupProperties.size() )
5943 {
5944 physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
5945 }
5946 return detail::createResultValueType( result, std::move( physicalDeviceGroupProperties ) );
5947 }
5948 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5949
5950 // wrapper function for command vkGetImageMemoryRequirements2, see
5951 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements2.html
5952 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
5953 VULKAN_HPP_INLINE void Device::getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 * pInfo,
5954 MemoryRequirements2 * pMemoryRequirements,
5955 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
5956 {
5957 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
5958 d.vkGetImageMemoryRequirements2( static_cast<VkDevice>( m_device ),
5959 reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>( pInfo ),
5960 reinterpret_cast<VkMemoryRequirements2 *>( pMemoryRequirements ) );
5961 }
5962
5963 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5964 // wrapper function for command vkGetImageMemoryRequirements2, see
5965 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements2.html
5966 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
5967 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 Device::getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info,
5968 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
5969 {
5970 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
5971 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
5972 VULKAN_HPP_ASSERT( d.vkGetImageMemoryRequirements2 &&
5973 "Function <vkGetImageMemoryRequirements2> requires <VK_KHR_get_memory_requirements2> or <VK_VERSION_1_1>" );
5974 # endif
5975
5976 MemoryRequirements2 memoryRequirements;
5977 d.vkGetImageMemoryRequirements2(
5978 m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>( &info ), reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
5979
5980 return memoryRequirements;
5981 }
5982
5983 // wrapper function for command vkGetImageMemoryRequirements2, see
5984 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements2.html
5985 template <typename X, typename Y, typename... Z, typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
5986 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info,
5987 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
5988 {
5989 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
5990 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
5991 VULKAN_HPP_ASSERT( d.vkGetImageMemoryRequirements2 &&
5992 "Function <vkGetImageMemoryRequirements2> requires <VK_KHR_get_memory_requirements2> or <VK_VERSION_1_1>" );
5993 # endif
5994
5995 StructureChain<X, Y, Z...> structureChain;
5996 MemoryRequirements2 & memoryRequirements = structureChain.template get<MemoryRequirements2>();
5997 d.vkGetImageMemoryRequirements2(
5998 m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>( &info ), reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
5999
6000 return structureChain;
6001 }
6002 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6003
6004 // wrapper function for command vkGetBufferMemoryRequirements2, see
6005 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements2.html
6006 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
6007 VULKAN_HPP_INLINE void Device::getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 * pInfo,
6008 MemoryRequirements2 * pMemoryRequirements,
6009 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
6010 {
6011 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
6012 d.vkGetBufferMemoryRequirements2( static_cast<VkDevice>( m_device ),
6013 reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>( pInfo ),
6014 reinterpret_cast<VkMemoryRequirements2 *>( pMemoryRequirements ) );
6015 }
6016
6017 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6018 // wrapper function for command vkGetBufferMemoryRequirements2, see
6019 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements2.html
6020 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
6021 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 Device::getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info,
6022 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
6023 {
6024 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
6025 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
6026 VULKAN_HPP_ASSERT( d.vkGetBufferMemoryRequirements2 &&
6027 "Function <vkGetBufferMemoryRequirements2> requires <VK_KHR_get_memory_requirements2> or <VK_VERSION_1_1>" );
6028 # endif
6029
6030 MemoryRequirements2 memoryRequirements;
6031 d.vkGetBufferMemoryRequirements2(
6032 m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>( &info ), reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
6033
6034 return memoryRequirements;
6035 }
6036
6037 // wrapper function for command vkGetBufferMemoryRequirements2, see
6038 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements2.html
6039 template <typename X, typename Y, typename... Z, typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
6040 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info,
6041 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
6042 {
6043 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
6044 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
6045 VULKAN_HPP_ASSERT( d.vkGetBufferMemoryRequirements2 &&
6046 "Function <vkGetBufferMemoryRequirements2> requires <VK_KHR_get_memory_requirements2> or <VK_VERSION_1_1>" );
6047 # endif
6048
6049 StructureChain<X, Y, Z...> structureChain;
6050 MemoryRequirements2 & memoryRequirements = structureChain.template get<MemoryRequirements2>();
6051 d.vkGetBufferMemoryRequirements2(
6052 m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>( &info ), reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
6053
6054 return structureChain;
6055 }
6056 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6057
6058 // wrapper function for command vkGetImageSparseMemoryRequirements2, see
6059 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements2.html
6060 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
6061 VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 * pInfo,
6062 uint32_t * pSparseMemoryRequirementCount,
6063 SparseImageMemoryRequirements2 * pSparseMemoryRequirements,
6064 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
6065 {
6066 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
6067 d.vkGetImageSparseMemoryRequirements2( static_cast<VkDevice>( m_device ),
6068 reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( pInfo ),
6069 pSparseMemoryRequirementCount,
6070 reinterpret_cast<VkSparseImageMemoryRequirements2 *>( pSparseMemoryRequirements ) );
6071 }
6072
6073 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6074 // wrapper function for command vkGetImageSparseMemoryRequirements2, see
6075 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements2.html
6076 template <
6077 typename SparseImageMemoryRequirements2Allocator,
6078 typename Dispatch,
6079 typename std::enable_if<std::is_same<typename SparseImageMemoryRequirements2Allocator::value_type, SparseImageMemoryRequirements2>::value, int>::type,
6080 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
6081 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
6082 Device::getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 & info, Dispatch const & d ) const
6083 {
6084 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
6085 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
6086 VULKAN_HPP_ASSERT( d.vkGetImageSparseMemoryRequirements2 &&
6087 "Function <vkGetImageSparseMemoryRequirements2> requires <VK_KHR_get_memory_requirements2> or <VK_VERSION_1_1>" );
6088 # endif
6089
6090 std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> sparseMemoryRequirements;
6091 uint32_t sparseMemoryRequirementCount;
6092 d.vkGetImageSparseMemoryRequirements2(
6093 m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ), &sparseMemoryRequirementCount, nullptr );
6094 sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
6095 d.vkGetImageSparseMemoryRequirements2( m_device,
6096 reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ),
6097 &sparseMemoryRequirementCount,
6098 reinterpret_cast<VkSparseImageMemoryRequirements2 *>( sparseMemoryRequirements.data() ) );
6099
6100 VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() );
6101 if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() )
6102 {
6103 sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
6104 }
6105 return sparseMemoryRequirements;
6106 }
6107
6108 // wrapper function for command vkGetImageSparseMemoryRequirements2, see
6109 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements2.html
6110 template <
6111 typename SparseImageMemoryRequirements2Allocator,
6112 typename Dispatch,
6113 typename std::enable_if<std::is_same<typename SparseImageMemoryRequirements2Allocator::value_type, SparseImageMemoryRequirements2>::value, int>::type,
6114 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
6115 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
6116 Device::getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 & info,
6117 SparseImageMemoryRequirements2Allocator & sparseImageMemoryRequirements2Allocator,
6118 Dispatch const & d ) const
6119 {
6120 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
6121 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
6122 VULKAN_HPP_ASSERT( d.vkGetImageSparseMemoryRequirements2 &&
6123 "Function <vkGetImageSparseMemoryRequirements2> requires <VK_KHR_get_memory_requirements2> or <VK_VERSION_1_1>" );
6124 # endif
6125
6126 std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> sparseMemoryRequirements( sparseImageMemoryRequirements2Allocator );
6127 uint32_t sparseMemoryRequirementCount;
6128 d.vkGetImageSparseMemoryRequirements2(
6129 m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ), &sparseMemoryRequirementCount, nullptr );
6130 sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
6131 d.vkGetImageSparseMemoryRequirements2( m_device,
6132 reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ),
6133 &sparseMemoryRequirementCount,
6134 reinterpret_cast<VkSparseImageMemoryRequirements2 *>( sparseMemoryRequirements.data() ) );
6135
6136 VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() );
6137 if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() )
6138 {
6139 sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
6140 }
6141 return sparseMemoryRequirements;
6142 }
6143 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6144
6145 // wrapper function for command vkGetPhysicalDeviceFeatures2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures2.html
6146 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
6147 VULKAN_HPP_INLINE void PhysicalDevice::getFeatures2( PhysicalDeviceFeatures2 * pFeatures, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
6148 {
6149 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
6150 d.vkGetPhysicalDeviceFeatures2( static_cast<VkPhysicalDevice>( m_physicalDevice ), reinterpret_cast<VkPhysicalDeviceFeatures2 *>( pFeatures ) );
6151 }
6152
6153 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6154 // wrapper function for command vkGetPhysicalDeviceFeatures2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures2.html
6155 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
6156 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PhysicalDeviceFeatures2 PhysicalDevice::getFeatures2( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
6157 {
6158 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
6159 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
6160 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceFeatures2 &&
6161 "Function <vkGetPhysicalDeviceFeatures2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
6162 # endif
6163
6164 PhysicalDeviceFeatures2 features;
6165 d.vkGetPhysicalDeviceFeatures2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2 *>( &features ) );
6166
6167 return features;
6168 }
6169
6170 // wrapper function for command vkGetPhysicalDeviceFeatures2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures2.html
6171 template <typename X, typename Y, typename... Z, typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
6172 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getFeatures2( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
6173 {
6174 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
6175 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
6176 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceFeatures2 &&
6177 "Function <vkGetPhysicalDeviceFeatures2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
6178 # endif
6179
6180 StructureChain<X, Y, Z...> structureChain;
6181 PhysicalDeviceFeatures2 & features = structureChain.template get<PhysicalDeviceFeatures2>();
6182 d.vkGetPhysicalDeviceFeatures2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2 *>( &features ) );
6183
6184 return structureChain;
6185 }
6186 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6187
6188 // wrapper function for command vkGetPhysicalDeviceProperties2, see
6189 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties2.html
6190 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
6191 VULKAN_HPP_INLINE void PhysicalDevice::getProperties2( PhysicalDeviceProperties2 * pProperties, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
6192 {
6193 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
6194 d.vkGetPhysicalDeviceProperties2( static_cast<VkPhysicalDevice>( m_physicalDevice ), reinterpret_cast<VkPhysicalDeviceProperties2 *>( pProperties ) );
6195 }
6196
6197 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6198 // wrapper function for command vkGetPhysicalDeviceProperties2, see
6199 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties2.html
6200 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
6201 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PhysicalDeviceProperties2 PhysicalDevice::getProperties2( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
6202 {
6203 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
6204 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
6205 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceProperties2 &&
6206 "Function <vkGetPhysicalDeviceProperties2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
6207 # endif
6208
6209 PhysicalDeviceProperties2 properties;
6210 d.vkGetPhysicalDeviceProperties2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2 *>( &properties ) );
6211
6212 return properties;
6213 }
6214
6215 // wrapper function for command vkGetPhysicalDeviceProperties2, see
6216 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties2.html
6217 template <typename X, typename Y, typename... Z, typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
6218 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getProperties2( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
6219 {
6220 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
6221 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
6222 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceProperties2 &&
6223 "Function <vkGetPhysicalDeviceProperties2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
6224 # endif
6225
6226 StructureChain<X, Y, Z...> structureChain;
6227 PhysicalDeviceProperties2 & properties = structureChain.template get<PhysicalDeviceProperties2>();
6228 d.vkGetPhysicalDeviceProperties2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2 *>( &properties ) );
6229
6230 return structureChain;
6231 }
6232 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6233
6234 // wrapper function for command vkGetPhysicalDeviceFormatProperties2, see
6235 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties2.html
6236 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
6237 VULKAN_HPP_INLINE void
6238 PhysicalDevice::getFormatProperties2( Format format, FormatProperties2 * pFormatProperties, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
6239 {
6240 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
6241 d.vkGetPhysicalDeviceFormatProperties2(
6242 static_cast<VkPhysicalDevice>( m_physicalDevice ), static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2 *>( pFormatProperties ) );
6243 }
6244
6245 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6246 // wrapper function for command vkGetPhysicalDeviceFormatProperties2, see
6247 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties2.html
6248 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
6249 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE FormatProperties2 PhysicalDevice::getFormatProperties2( Format format, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
6250 {
6251 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
6252 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
6253 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceFormatProperties2 &&
6254 "Function <vkGetPhysicalDeviceFormatProperties2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
6255 # endif
6256
6257 FormatProperties2 formatProperties;
6258 d.vkGetPhysicalDeviceFormatProperties2( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2 *>( &formatProperties ) );
6259
6260 return formatProperties;
6261 }
6262
6263 // wrapper function for command vkGetPhysicalDeviceFormatProperties2, see
6264 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties2.html
6265 template <typename X, typename Y, typename... Z, typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
6266 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getFormatProperties2( Format format,
6267 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
6268 {
6269 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
6270 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
6271 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceFormatProperties2 &&
6272 "Function <vkGetPhysicalDeviceFormatProperties2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
6273 # endif
6274
6275 StructureChain<X, Y, Z...> structureChain;
6276 FormatProperties2 & formatProperties = structureChain.template get<FormatProperties2>();
6277 d.vkGetPhysicalDeviceFormatProperties2( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2 *>( &formatProperties ) );
6278
6279 return structureChain;
6280 }
6281 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6282
6283 // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2, see
6284 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2.html
6285 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
6286 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 * pImageFormatInfo,
6287 ImageFormatProperties2 * pImageFormatProperties,
6288 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
6289 {
6290 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
6291 return static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2( static_cast<VkPhysicalDevice>( m_physicalDevice ),
6292 reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>( pImageFormatInfo ),
6293 reinterpret_cast<VkImageFormatProperties2 *>( pImageFormatProperties ) ) );
6294 }
6295
6296 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6297 // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2, see
6298 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2.html
6299 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
6300 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<ImageFormatProperties2>::type
6301 PhysicalDevice::getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const & d ) const
6302 {
6303 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
6304 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
6305 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceImageFormatProperties2 &&
6306 "Function <vkGetPhysicalDeviceImageFormatProperties2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
6307 # endif
6308
6309 ImageFormatProperties2 imageFormatProperties;
6310 Result result =
6311 static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2( m_physicalDevice,
6312 reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>( &imageFormatInfo ),
6313 reinterpret_cast<VkImageFormatProperties2 *>( &imageFormatProperties ) ) );
6314 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2" );
6315
6316 return detail::createResultValueType( result, std::move( imageFormatProperties ) );
6317 }
6318
6319 // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2, see
6320 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2.html
6321 template <typename X, typename Y, typename... Z, typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
6322 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<StructureChain<X, Y, Z...>>::type
6323 PhysicalDevice::getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const & d ) const
6324 {
6325 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
6326 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
6327 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceImageFormatProperties2 &&
6328 "Function <vkGetPhysicalDeviceImageFormatProperties2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
6329 # endif
6330
6331 StructureChain<X, Y, Z...> structureChain;
6332 ImageFormatProperties2 & imageFormatProperties = structureChain.template get<ImageFormatProperties2>();
6333 Result result =
6334 static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2( m_physicalDevice,
6335 reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>( &imageFormatInfo ),
6336 reinterpret_cast<VkImageFormatProperties2 *>( &imageFormatProperties ) ) );
6337 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2" );
6338
6339 return detail::createResultValueType( result, std::move( structureChain ) );
6340 }
6341 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6342
6343 // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2, see
6344 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2.html
6345 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
6346 VULKAN_HPP_INLINE void PhysicalDevice::getQueueFamilyProperties2( uint32_t * pQueueFamilyPropertyCount,
6347 QueueFamilyProperties2 * pQueueFamilyProperties,
6348 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
6349 {
6350 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
6351 d.vkGetPhysicalDeviceQueueFamilyProperties2(
6352 static_cast<VkPhysicalDevice>( m_physicalDevice ), pQueueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2 *>( pQueueFamilyProperties ) );
6353 }
6354
6355 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6356 // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2, see
6357 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2.html
6358 template <typename QueueFamilyProperties2Allocator,
6359 typename Dispatch,
6360 typename std::enable_if<std::is_same<typename QueueFamilyProperties2Allocator::value_type, QueueFamilyProperties2>::value, int>::type,
6361 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
6362 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator>
6363 PhysicalDevice::getQueueFamilyProperties2( Dispatch const & d ) const
6364 {
6365 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
6366 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
6367 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyProperties2 &&
6368 "Function <vkGetPhysicalDeviceQueueFamilyProperties2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
6369 # endif
6370
6371 std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator> queueFamilyProperties;
6372 uint32_t queueFamilyPropertyCount;
6373 d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
6374 queueFamilyProperties.resize( queueFamilyPropertyCount );
6375 d.vkGetPhysicalDeviceQueueFamilyProperties2(
6376 m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) );
6377
6378 VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() );
6379 if ( queueFamilyPropertyCount < queueFamilyProperties.size() )
6380 {
6381 queueFamilyProperties.resize( queueFamilyPropertyCount );
6382 }
6383 return queueFamilyProperties;
6384 }
6385
6386 // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2, see
6387 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2.html
6388 template <typename QueueFamilyProperties2Allocator,
6389 typename Dispatch,
6390 typename std::enable_if<std::is_same<typename QueueFamilyProperties2Allocator::value_type, QueueFamilyProperties2>::value, int>::type,
6391 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
6392 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator>
6393 PhysicalDevice::getQueueFamilyProperties2( QueueFamilyProperties2Allocator & queueFamilyProperties2Allocator, Dispatch const & d ) const
6394 {
6395 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
6396 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
6397 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyProperties2 &&
6398 "Function <vkGetPhysicalDeviceQueueFamilyProperties2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
6399 # endif
6400
6401 std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator> queueFamilyProperties( queueFamilyProperties2Allocator );
6402 uint32_t queueFamilyPropertyCount;
6403 d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
6404 queueFamilyProperties.resize( queueFamilyPropertyCount );
6405 d.vkGetPhysicalDeviceQueueFamilyProperties2(
6406 m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) );
6407
6408 VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() );
6409 if ( queueFamilyPropertyCount < queueFamilyProperties.size() )
6410 {
6411 queueFamilyProperties.resize( queueFamilyPropertyCount );
6412 }
6413 return queueFamilyProperties;
6414 }
6415
6416 // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2, see
6417 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2.html
6418 template <typename StructureChain,
6419 typename StructureChainAllocator,
6420 typename Dispatch,
6421 typename std::enable_if<std::is_same<typename StructureChainAllocator::value_type, StructureChain>::value, int>::type,
6422 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
6423 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<StructureChain, StructureChainAllocator>
6424 PhysicalDevice::getQueueFamilyProperties2( Dispatch const & d ) const
6425 {
6426 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
6427 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
6428 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyProperties2 &&
6429 "Function <vkGetPhysicalDeviceQueueFamilyProperties2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
6430 # endif
6431
6432 std::vector<StructureChain, StructureChainAllocator> structureChains;
6433 std::vector<QueueFamilyProperties2> queueFamilyProperties;
6434 uint32_t queueFamilyPropertyCount;
6435 d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
6436 structureChains.resize( queueFamilyPropertyCount );
6437 queueFamilyProperties.resize( queueFamilyPropertyCount );
6438 for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ )
6439 {
6440 queueFamilyProperties[i].pNext = structureChains[i].template get<QueueFamilyProperties2>().pNext;
6441 }
6442 d.vkGetPhysicalDeviceQueueFamilyProperties2(
6443 m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) );
6444
6445 VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() );
6446 if ( queueFamilyPropertyCount < queueFamilyProperties.size() )
6447 {
6448 structureChains.resize( queueFamilyPropertyCount );
6449 }
6450 for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ )
6451 {
6452 structureChains[i].template get<QueueFamilyProperties2>() = queueFamilyProperties[i];
6453 }
6454 return structureChains;
6455 }
6456
6457 // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2, see
6458 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2.html
6459 template <typename StructureChain,
6460 typename StructureChainAllocator,
6461 typename Dispatch,
6462 typename std::enable_if<std::is_same<typename StructureChainAllocator::value_type, StructureChain>::value, int>::type,
6463 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
6464 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<StructureChain, StructureChainAllocator>
6465 PhysicalDevice::getQueueFamilyProperties2( StructureChainAllocator & structureChainAllocator, Dispatch const & d ) const
6466 {
6467 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
6468 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
6469 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyProperties2 &&
6470 "Function <vkGetPhysicalDeviceQueueFamilyProperties2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
6471 # endif
6472
6473 std::vector<StructureChain, StructureChainAllocator> structureChains( structureChainAllocator );
6474 std::vector<QueueFamilyProperties2> queueFamilyProperties;
6475 uint32_t queueFamilyPropertyCount;
6476 d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
6477 structureChains.resize( queueFamilyPropertyCount );
6478 queueFamilyProperties.resize( queueFamilyPropertyCount );
6479 for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ )
6480 {
6481 queueFamilyProperties[i].pNext = structureChains[i].template get<QueueFamilyProperties2>().pNext;
6482 }
6483 d.vkGetPhysicalDeviceQueueFamilyProperties2(
6484 m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) );
6485
6486 VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() );
6487 if ( queueFamilyPropertyCount < queueFamilyProperties.size() )
6488 {
6489 structureChains.resize( queueFamilyPropertyCount );
6490 }
6491 for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ )
6492 {
6493 structureChains[i].template get<QueueFamilyProperties2>() = queueFamilyProperties[i];
6494 }
6495 return structureChains;
6496 }
6497 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6498
6499 // wrapper function for command vkGetPhysicalDeviceMemoryProperties2, see
6500 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties2.html
6501 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
6502 VULKAN_HPP_INLINE void PhysicalDevice::getMemoryProperties2( PhysicalDeviceMemoryProperties2 * pMemoryProperties,
6503 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
6504 {
6505 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
6506 d.vkGetPhysicalDeviceMemoryProperties2( static_cast<VkPhysicalDevice>( m_physicalDevice ),
6507 reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>( pMemoryProperties ) );
6508 }
6509
6510 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6511 // wrapper function for command vkGetPhysicalDeviceMemoryProperties2, see
6512 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties2.html
6513 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
6514 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PhysicalDeviceMemoryProperties2 PhysicalDevice::getMemoryProperties2( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
6515 {
6516 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
6517 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
6518 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceMemoryProperties2 &&
6519 "Function <vkGetPhysicalDeviceMemoryProperties2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
6520 # endif
6521
6522 PhysicalDeviceMemoryProperties2 memoryProperties;
6523 d.vkGetPhysicalDeviceMemoryProperties2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>( &memoryProperties ) );
6524
6525 return memoryProperties;
6526 }
6527
6528 // wrapper function for command vkGetPhysicalDeviceMemoryProperties2, see
6529 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties2.html
6530 template <typename X, typename Y, typename... Z, typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
6531 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getMemoryProperties2( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
6532 {
6533 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
6534 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
6535 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceMemoryProperties2 &&
6536 "Function <vkGetPhysicalDeviceMemoryProperties2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
6537 # endif
6538
6539 StructureChain<X, Y, Z...> structureChain;
6540 PhysicalDeviceMemoryProperties2 & memoryProperties = structureChain.template get<PhysicalDeviceMemoryProperties2>();
6541 d.vkGetPhysicalDeviceMemoryProperties2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>( &memoryProperties ) );
6542
6543 return structureChain;
6544 }
6545 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6546
6547 // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties2, see
6548 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2.html
6549 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
6550 VULKAN_HPP_INLINE void PhysicalDevice::getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,
6551 uint32_t * pPropertyCount,
6552 SparseImageFormatProperties2 * pProperties,
6553 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
6554 {
6555 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
6556 d.vkGetPhysicalDeviceSparseImageFormatProperties2( static_cast<VkPhysicalDevice>( m_physicalDevice ),
6557 reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( pFormatInfo ),
6558 pPropertyCount,
6559 reinterpret_cast<VkSparseImageFormatProperties2 *>( pProperties ) );
6560 }
6561
6562 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6563 // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties2, see
6564 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2.html
6565 template <typename SparseImageFormatProperties2Allocator,
6566 typename Dispatch,
6567 typename std::enable_if<std::is_same<typename SparseImageFormatProperties2Allocator::value_type, SparseImageFormatProperties2>::value, int>::type,
6568 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
6569 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
6570 PhysicalDevice::getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Dispatch const & d ) const
6571 {
6572 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
6573 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
6574 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSparseImageFormatProperties2 &&
6575 "Function <vkGetPhysicalDeviceSparseImageFormatProperties2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
6576 # endif
6577
6578 std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator> properties;
6579 uint32_t propertyCount;
6580 d.vkGetPhysicalDeviceSparseImageFormatProperties2(
6581 m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ), &propertyCount, nullptr );
6582 properties.resize( propertyCount );
6583 d.vkGetPhysicalDeviceSparseImageFormatProperties2( m_physicalDevice,
6584 reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ),
6585 &propertyCount,
6586 reinterpret_cast<VkSparseImageFormatProperties2 *>( properties.data() ) );
6587
6588 VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
6589 if ( propertyCount < properties.size() )
6590 {
6591 properties.resize( propertyCount );
6592 }
6593 return properties;
6594 }
6595
6596 // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties2, see
6597 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2.html
6598 template <typename SparseImageFormatProperties2Allocator,
6599 typename Dispatch,
6600 typename std::enable_if<std::is_same<typename SparseImageFormatProperties2Allocator::value_type, SparseImageFormatProperties2>::value, int>::type,
6601 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
6602 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
6603 PhysicalDevice::getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
6604 SparseImageFormatProperties2Allocator & sparseImageFormatProperties2Allocator,
6605 Dispatch const & d ) const
6606 {
6607 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
6608 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
6609 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSparseImageFormatProperties2 &&
6610 "Function <vkGetPhysicalDeviceSparseImageFormatProperties2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
6611 # endif
6612
6613 std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator> properties( sparseImageFormatProperties2Allocator );
6614 uint32_t propertyCount;
6615 d.vkGetPhysicalDeviceSparseImageFormatProperties2(
6616 m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ), &propertyCount, nullptr );
6617 properties.resize( propertyCount );
6618 d.vkGetPhysicalDeviceSparseImageFormatProperties2( m_physicalDevice,
6619 reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ),
6620 &propertyCount,
6621 reinterpret_cast<VkSparseImageFormatProperties2 *>( properties.data() ) );
6622
6623 VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
6624 if ( propertyCount < properties.size() )
6625 {
6626 properties.resize( propertyCount );
6627 }
6628 return properties;
6629 }
6630 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6631
6632 // wrapper function for command vkTrimCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkTrimCommandPool.html
6633 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
6634 VULKAN_HPP_INLINE void Device::trimCommandPool( CommandPool commandPool, CommandPoolTrimFlags flags, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
6635 {
6636 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
6637 d.vkTrimCommandPool( static_cast<VkDevice>( m_device ), static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolTrimFlags>( flags ) );
6638 }
6639
6640 // wrapper function for command vkGetDeviceQueue2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceQueue2.html
6641 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
6642 VULKAN_HPP_INLINE void Device::getQueue2( const DeviceQueueInfo2 * pQueueInfo, Queue * pQueue, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
6643 {
6644 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
6645 d.vkGetDeviceQueue2( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkDeviceQueueInfo2 *>( pQueueInfo ), reinterpret_cast<VkQueue *>( pQueue ) );
6646 }
6647
6648 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6649 // wrapper function for command vkGetDeviceQueue2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceQueue2.html
6650 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
6651 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Queue Device::getQueue2( const DeviceQueueInfo2 & queueInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
6652 {
6653 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
6654 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
6655 VULKAN_HPP_ASSERT( d.vkGetDeviceQueue2 && "Function <vkGetDeviceQueue2> requires <VK_VERSION_1_1>" );
6656 # endif
6657
6658 Queue queue;
6659 d.vkGetDeviceQueue2( m_device, reinterpret_cast<const VkDeviceQueueInfo2 *>( &queueInfo ), reinterpret_cast<VkQueue *>( &queue ) );
6660
6661 return queue;
6662 }
6663 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6664
6665 // wrapper function for command vkGetPhysicalDeviceExternalBufferProperties, see
6666 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalBufferProperties.html
6667 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
6668 VULKAN_HPP_INLINE void PhysicalDevice::getExternalBufferProperties( const PhysicalDeviceExternalBufferInfo * pExternalBufferInfo,
6669 ExternalBufferProperties * pExternalBufferProperties,
6670 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
6671 {
6672 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
6673 d.vkGetPhysicalDeviceExternalBufferProperties( static_cast<VkPhysicalDevice>( m_physicalDevice ),
6674 reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo *>( pExternalBufferInfo ),
6675 reinterpret_cast<VkExternalBufferProperties *>( pExternalBufferProperties ) );
6676 }
6677
6678 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6679 // wrapper function for command vkGetPhysicalDeviceExternalBufferProperties, see
6680 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalBufferProperties.html
6681 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
6682 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ExternalBufferProperties
6683 PhysicalDevice::getExternalBufferProperties( const PhysicalDeviceExternalBufferInfo & externalBufferInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
6684 {
6685 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
6686 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
6687 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceExternalBufferProperties &&
6688 "Function <vkGetPhysicalDeviceExternalBufferProperties> requires <VK_KHR_external_memory_capabilities> or <VK_VERSION_1_1>" );
6689 # endif
6690
6691 ExternalBufferProperties externalBufferProperties;
6692 d.vkGetPhysicalDeviceExternalBufferProperties( m_physicalDevice,
6693 reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo *>( &externalBufferInfo ),
6694 reinterpret_cast<VkExternalBufferProperties *>( &externalBufferProperties ) );
6695
6696 return externalBufferProperties;
6697 }
6698 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6699
6700 // wrapper function for command vkGetPhysicalDeviceExternalFenceProperties, see
6701 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalFenceProperties.html
6702 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
6703 VULKAN_HPP_INLINE void PhysicalDevice::getExternalFenceProperties( const PhysicalDeviceExternalFenceInfo * pExternalFenceInfo,
6704 ExternalFenceProperties * pExternalFenceProperties,
6705 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
6706 {
6707 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
6708 d.vkGetPhysicalDeviceExternalFenceProperties( static_cast<VkPhysicalDevice>( m_physicalDevice ),
6709 reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo *>( pExternalFenceInfo ),
6710 reinterpret_cast<VkExternalFenceProperties *>( pExternalFenceProperties ) );
6711 }
6712
6713 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6714 // wrapper function for command vkGetPhysicalDeviceExternalFenceProperties, see
6715 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalFenceProperties.html
6716 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
6717 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ExternalFenceProperties
6718 PhysicalDevice::getExternalFenceProperties( const PhysicalDeviceExternalFenceInfo & externalFenceInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
6719 {
6720 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
6721 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
6722 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceExternalFenceProperties &&
6723 "Function <vkGetPhysicalDeviceExternalFenceProperties> requires <VK_KHR_external_fence_capabilities> or <VK_VERSION_1_1>" );
6724 # endif
6725
6726 ExternalFenceProperties externalFenceProperties;
6727 d.vkGetPhysicalDeviceExternalFenceProperties( m_physicalDevice,
6728 reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo *>( &externalFenceInfo ),
6729 reinterpret_cast<VkExternalFenceProperties *>( &externalFenceProperties ) );
6730
6731 return externalFenceProperties;
6732 }
6733 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6734
6735 // wrapper function for command vkGetPhysicalDeviceExternalSemaphoreProperties, see
6736 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalSemaphoreProperties.html
6737 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
6738 VULKAN_HPP_INLINE void PhysicalDevice::getExternalSemaphoreProperties( const PhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,
6739 ExternalSemaphoreProperties * pExternalSemaphoreProperties,
6740 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
6741 {
6742 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
6743 d.vkGetPhysicalDeviceExternalSemaphoreProperties( static_cast<VkPhysicalDevice>( m_physicalDevice ),
6744 reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo *>( pExternalSemaphoreInfo ),
6745 reinterpret_cast<VkExternalSemaphoreProperties *>( pExternalSemaphoreProperties ) );
6746 }
6747
6748 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6749 // wrapper function for command vkGetPhysicalDeviceExternalSemaphoreProperties, see
6750 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalSemaphoreProperties.html
6751 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
6752 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ExternalSemaphoreProperties PhysicalDevice::getExternalSemaphoreProperties(
6753 const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
6754 {
6755 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
6756 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
6757 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceExternalSemaphoreProperties &&
6758 "Function <vkGetPhysicalDeviceExternalSemaphoreProperties> requires <VK_KHR_external_semaphore_capabilities> or <VK_VERSION_1_1>" );
6759 # endif
6760
6761 ExternalSemaphoreProperties externalSemaphoreProperties;
6762 d.vkGetPhysicalDeviceExternalSemaphoreProperties( m_physicalDevice,
6763 reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo *>( &externalSemaphoreInfo ),
6764 reinterpret_cast<VkExternalSemaphoreProperties *>( &externalSemaphoreProperties ) );
6765
6766 return externalSemaphoreProperties;
6767 }
6768 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6769
6770 // wrapper function for command vkCmdDispatchBase, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchBase.html
6771 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
6772 VULKAN_HPP_INLINE void CommandBuffer::dispatchBase( uint32_t baseGroupX,
6773 uint32_t baseGroupY,
6774 uint32_t baseGroupZ,
6775 uint32_t groupCountX,
6776 uint32_t groupCountY,
6777 uint32_t groupCountZ,
6778 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
6779 {
6780 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
6781 d.vkCmdDispatchBase( static_cast<VkCommandBuffer>( m_commandBuffer ), baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ );
6782 }
6783
6784 // wrapper function for command vkCreateDescriptorUpdateTemplate, see
6785 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorUpdateTemplate.html
6786 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
6787 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createDescriptorUpdateTemplate( const DescriptorUpdateTemplateCreateInfo * pCreateInfo,
6788 const AllocationCallbacks * pAllocator,
6789 DescriptorUpdateTemplate * pDescriptorUpdateTemplate,
6790 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
6791 {
6792 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
6793 return static_cast<Result>( d.vkCreateDescriptorUpdateTemplate( static_cast<VkDevice>( m_device ),
6794 reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo *>( pCreateInfo ),
6795 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
6796 reinterpret_cast<VkDescriptorUpdateTemplate *>( pDescriptorUpdateTemplate ) ) );
6797 }
6798
6799 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6800 // wrapper function for command vkCreateDescriptorUpdateTemplate, see
6801 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorUpdateTemplate.html
6802 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
6803 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<DescriptorUpdateTemplate>::type Device::createDescriptorUpdateTemplate(
6804 const DescriptorUpdateTemplateCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
6805 {
6806 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
6807 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
6808 VULKAN_HPP_ASSERT( d.vkCreateDescriptorUpdateTemplate &&
6809 "Function <vkCreateDescriptorUpdateTemplate> requires <VK_KHR_descriptor_update_template> or <VK_VERSION_1_1>" );
6810 # endif
6811
6812 DescriptorUpdateTemplate descriptorUpdateTemplate;
6813 Result result = static_cast<Result>( d.vkCreateDescriptorUpdateTemplate( m_device,
6814 reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo *>( &createInfo ),
6815 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
6816 reinterpret_cast<VkDescriptorUpdateTemplate *>( &descriptorUpdateTemplate ) ) );
6817 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorUpdateTemplate" );
6818
6819 return detail::createResultValueType( result, std::move( descriptorUpdateTemplate ) );
6820 }
6821
6822 # ifndef VULKAN_HPP_NO_SMART_HANDLE
6823 // wrapper function for command vkCreateDescriptorUpdateTemplate, see
6824 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorUpdateTemplate.html
6825 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
6826 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<DescriptorUpdateTemplate, Dispatch>>::type
6827 Device::createDescriptorUpdateTemplateUnique( const DescriptorUpdateTemplateCreateInfo & createInfo,
6828 Optional<const AllocationCallbacks> allocator,
6829 Dispatch const & d ) const
6830 {
6831 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
6832 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
6833 VULKAN_HPP_ASSERT( d.vkCreateDescriptorUpdateTemplate &&
6834 "Function <vkCreateDescriptorUpdateTemplate> requires <VK_KHR_descriptor_update_template> or <VK_VERSION_1_1>" );
6835 # endif
6836
6837 DescriptorUpdateTemplate descriptorUpdateTemplate;
6838 Result result = static_cast<Result>( d.vkCreateDescriptorUpdateTemplate( m_device,
6839 reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo *>( &createInfo ),
6840 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
6841 reinterpret_cast<VkDescriptorUpdateTemplate *>( &descriptorUpdateTemplate ) ) );
6842 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorUpdateTemplateUnique" );
6843
6844 return detail::createResultValueType(
6845 result, UniqueHandle<DescriptorUpdateTemplate, Dispatch>( descriptorUpdateTemplate, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
6846 }
6847 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
6848 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6849
6850 // wrapper function for command vkDestroyDescriptorUpdateTemplate, see
6851 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorUpdateTemplate.html
6852 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
6853 VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplate( DescriptorUpdateTemplate descriptorUpdateTemplate,
6854 const AllocationCallbacks * pAllocator,
6855 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
6856 {
6857 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
6858 d.vkDestroyDescriptorUpdateTemplate( static_cast<VkDevice>( m_device ),
6859 static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
6860 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
6861 }
6862
6863 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6864 // wrapper function for command vkDestroyDescriptorUpdateTemplate, see
6865 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorUpdateTemplate.html
6866 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
6867 VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplate( DescriptorUpdateTemplate descriptorUpdateTemplate,
6868 Optional<const AllocationCallbacks> allocator,
6869 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
6870 {
6871 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
6872 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
6873 VULKAN_HPP_ASSERT( d.vkDestroyDescriptorUpdateTemplate &&
6874 "Function <vkDestroyDescriptorUpdateTemplate> requires <VK_KHR_descriptor_update_template> or <VK_VERSION_1_1>" );
6875 # endif
6876
6877 d.vkDestroyDescriptorUpdateTemplate(
6878 m_device, static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
6879 }
6880 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6881
6882 // wrapper function for command vkDestroyDescriptorUpdateTemplate, see
6883 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorUpdateTemplate.html
6884 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
6885 VULKAN_HPP_INLINE void
6886 Device::destroy( DescriptorUpdateTemplate descriptorUpdateTemplate, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
6887 {
6888 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
6889 d.vkDestroyDescriptorUpdateTemplate( static_cast<VkDevice>( m_device ),
6890 static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
6891 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
6892 }
6893
6894 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6895 // wrapper function for command vkDestroyDescriptorUpdateTemplate, see
6896 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorUpdateTemplate.html
6897 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
6898 VULKAN_HPP_INLINE void Device::destroy( DescriptorUpdateTemplate descriptorUpdateTemplate,
6899 Optional<const AllocationCallbacks> allocator,
6900 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
6901 {
6902 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
6903 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
6904 VULKAN_HPP_ASSERT( d.vkDestroyDescriptorUpdateTemplate &&
6905 "Function <vkDestroyDescriptorUpdateTemplate> requires <VK_KHR_descriptor_update_template> or <VK_VERSION_1_1>" );
6906 # endif
6907
6908 d.vkDestroyDescriptorUpdateTemplate(
6909 m_device, static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
6910 }
6911 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6912
6913 // wrapper function for command vkUpdateDescriptorSetWithTemplate, see
6914 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateDescriptorSetWithTemplate.html
6915 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
6916 VULKAN_HPP_INLINE void Device::updateDescriptorSetWithTemplate( DescriptorSet descriptorSet,
6917 DescriptorUpdateTemplate descriptorUpdateTemplate,
6918 const void * pData,
6919 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
6920 {
6921 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
6922 d.vkUpdateDescriptorSetWithTemplate( static_cast<VkDevice>( m_device ),
6923 static_cast<VkDescriptorSet>( descriptorSet ),
6924 static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
6925 pData );
6926 }
6927
6928 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6929 // wrapper function for command vkUpdateDescriptorSetWithTemplate, see
6930 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateDescriptorSetWithTemplate.html
6931 template <typename DataType, typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
6932 VULKAN_HPP_INLINE void Device::updateDescriptorSetWithTemplate( DescriptorSet descriptorSet,
6933 DescriptorUpdateTemplate descriptorUpdateTemplate,
6934 DataType const & data,
6935 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
6936 {
6937 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
6938 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
6939 VULKAN_HPP_ASSERT( d.vkUpdateDescriptorSetWithTemplate &&
6940 "Function <vkUpdateDescriptorSetWithTemplate> requires <VK_KHR_descriptor_update_template> or <VK_VERSION_1_1>" );
6941 # endif
6942
6943 d.vkUpdateDescriptorSetWithTemplate( m_device,
6944 static_cast<VkDescriptorSet>( descriptorSet ),
6945 static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
6946 reinterpret_cast<const void *>( &data ) );
6947 }
6948 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6949
6950 // wrapper function for command vkGetDescriptorSetLayoutSupport, see
6951 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSupport.html
6952 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
6953 VULKAN_HPP_INLINE void Device::getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo * pCreateInfo,
6954 DescriptorSetLayoutSupport * pSupport,
6955 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
6956 {
6957 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
6958 d.vkGetDescriptorSetLayoutSupport( static_cast<VkDevice>( m_device ),
6959 reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( pCreateInfo ),
6960 reinterpret_cast<VkDescriptorSetLayoutSupport *>( pSupport ) );
6961 }
6962
6963 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6964 // wrapper function for command vkGetDescriptorSetLayoutSupport, see
6965 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSupport.html
6966 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
6967 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DescriptorSetLayoutSupport Device::getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo,
6968 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
6969 {
6970 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
6971 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
6972 VULKAN_HPP_ASSERT( d.vkGetDescriptorSetLayoutSupport && "Function <vkGetDescriptorSetLayoutSupport> requires <VK_KHR_maintenance3> or <VK_VERSION_1_1>" );
6973 # endif
6974
6975 DescriptorSetLayoutSupport support;
6976 d.vkGetDescriptorSetLayoutSupport(
6977 m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( &createInfo ), reinterpret_cast<VkDescriptorSetLayoutSupport *>( &support ) );
6978
6979 return support;
6980 }
6981
6982 // wrapper function for command vkGetDescriptorSetLayoutSupport, see
6983 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSupport.html
6984 template <typename X, typename Y, typename... Z, typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
6985 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo,
6986 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
6987 {
6988 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
6989 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
6990 VULKAN_HPP_ASSERT( d.vkGetDescriptorSetLayoutSupport && "Function <vkGetDescriptorSetLayoutSupport> requires <VK_KHR_maintenance3> or <VK_VERSION_1_1>" );
6991 # endif
6992
6993 StructureChain<X, Y, Z...> structureChain;
6994 DescriptorSetLayoutSupport & support = structureChain.template get<DescriptorSetLayoutSupport>();
6995 d.vkGetDescriptorSetLayoutSupport(
6996 m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( &createInfo ), reinterpret_cast<VkDescriptorSetLayoutSupport *>( &support ) );
6997
6998 return structureChain;
6999 }
7000 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7001
7002 // wrapper function for command vkCreateSamplerYcbcrConversion, see
7003 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSamplerYcbcrConversion.html
7004 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
7005 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createSamplerYcbcrConversion( const SamplerYcbcrConversionCreateInfo * pCreateInfo,
7006 const AllocationCallbacks * pAllocator,
7007 SamplerYcbcrConversion * pYcbcrConversion,
7008 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
7009 {
7010 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
7011 return static_cast<Result>( d.vkCreateSamplerYcbcrConversion( static_cast<VkDevice>( m_device ),
7012 reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo *>( pCreateInfo ),
7013 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
7014 reinterpret_cast<VkSamplerYcbcrConversion *>( pYcbcrConversion ) ) );
7015 }
7016
7017 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7018 // wrapper function for command vkCreateSamplerYcbcrConversion, see
7019 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSamplerYcbcrConversion.html
7020 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
7021 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<SamplerYcbcrConversion>::type Device::createSamplerYcbcrConversion(
7022 const SamplerYcbcrConversionCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
7023 {
7024 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
7025 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
7026 VULKAN_HPP_ASSERT( d.vkCreateSamplerYcbcrConversion &&
7027 "Function <vkCreateSamplerYcbcrConversion> requires <VK_KHR_sampler_ycbcr_conversion> or <VK_VERSION_1_1>" );
7028 # endif
7029
7030 SamplerYcbcrConversion ycbcrConversion;
7031 Result result = static_cast<Result>( d.vkCreateSamplerYcbcrConversion( m_device,
7032 reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo *>( &createInfo ),
7033 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
7034 reinterpret_cast<VkSamplerYcbcrConversion *>( &ycbcrConversion ) ) );
7035 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSamplerYcbcrConversion" );
7036
7037 return detail::createResultValueType( result, std::move( ycbcrConversion ) );
7038 }
7039
7040 # ifndef VULKAN_HPP_NO_SMART_HANDLE
7041 // wrapper function for command vkCreateSamplerYcbcrConversion, see
7042 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSamplerYcbcrConversion.html
7043 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
7044 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SamplerYcbcrConversion, Dispatch>>::type
7045 Device::createSamplerYcbcrConversionUnique( const SamplerYcbcrConversionCreateInfo & createInfo,
7046 Optional<const AllocationCallbacks> allocator,
7047 Dispatch const & d ) const
7048 {
7049 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
7050 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
7051 VULKAN_HPP_ASSERT( d.vkCreateSamplerYcbcrConversion &&
7052 "Function <vkCreateSamplerYcbcrConversion> requires <VK_KHR_sampler_ycbcr_conversion> or <VK_VERSION_1_1>" );
7053 # endif
7054
7055 SamplerYcbcrConversion ycbcrConversion;
7056 Result result = static_cast<Result>( d.vkCreateSamplerYcbcrConversion( m_device,
7057 reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo *>( &createInfo ),
7058 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
7059 reinterpret_cast<VkSamplerYcbcrConversion *>( &ycbcrConversion ) ) );
7060 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSamplerYcbcrConversionUnique" );
7061
7062 return detail::createResultValueType(
7063 result, UniqueHandle<SamplerYcbcrConversion, Dispatch>( ycbcrConversion, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
7064 }
7065 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
7066 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7067
7068 // wrapper function for command vkDestroySamplerYcbcrConversion, see
7069 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySamplerYcbcrConversion.html
7070 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
7071 VULKAN_HPP_INLINE void Device::destroySamplerYcbcrConversion( SamplerYcbcrConversion ycbcrConversion,
7072 const AllocationCallbacks * pAllocator,
7073 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
7074 {
7075 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
7076 d.vkDestroySamplerYcbcrConversion( static_cast<VkDevice>( m_device ),
7077 static_cast<VkSamplerYcbcrConversion>( ycbcrConversion ),
7078 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
7079 }
7080
7081 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7082 // wrapper function for command vkDestroySamplerYcbcrConversion, see
7083 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySamplerYcbcrConversion.html
7084 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
7085 VULKAN_HPP_INLINE void Device::destroySamplerYcbcrConversion( SamplerYcbcrConversion ycbcrConversion,
7086 Optional<const AllocationCallbacks> allocator,
7087 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
7088 {
7089 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
7090 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
7091 VULKAN_HPP_ASSERT( d.vkDestroySamplerYcbcrConversion &&
7092 "Function <vkDestroySamplerYcbcrConversion> requires <VK_KHR_sampler_ycbcr_conversion> or <VK_VERSION_1_1>" );
7093 # endif
7094
7095 d.vkDestroySamplerYcbcrConversion(
7096 m_device, static_cast<VkSamplerYcbcrConversion>( ycbcrConversion ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
7097 }
7098 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7099
7100 // wrapper function for command vkDestroySamplerYcbcrConversion, see
7101 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySamplerYcbcrConversion.html
7102 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
7103 VULKAN_HPP_INLINE void
7104 Device::destroy( SamplerYcbcrConversion ycbcrConversion, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
7105 {
7106 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
7107 d.vkDestroySamplerYcbcrConversion( static_cast<VkDevice>( m_device ),
7108 static_cast<VkSamplerYcbcrConversion>( ycbcrConversion ),
7109 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
7110 }
7111
7112 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7113 // wrapper function for command vkDestroySamplerYcbcrConversion, see
7114 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySamplerYcbcrConversion.html
7115 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
7116 VULKAN_HPP_INLINE void
7117 Device::destroy( SamplerYcbcrConversion ycbcrConversion, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
7118 {
7119 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
7120 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
7121 VULKAN_HPP_ASSERT( d.vkDestroySamplerYcbcrConversion &&
7122 "Function <vkDestroySamplerYcbcrConversion> requires <VK_KHR_sampler_ycbcr_conversion> or <VK_VERSION_1_1>" );
7123 # endif
7124
7125 d.vkDestroySamplerYcbcrConversion(
7126 m_device, static_cast<VkSamplerYcbcrConversion>( ycbcrConversion ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
7127 }
7128 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7129
7130 //=== VK_VERSION_1_2 ===
7131
7132 // wrapper function for command vkResetQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetQueryPool.html
7133 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
7134 VULKAN_HPP_INLINE void Device::resetQueryPool( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
7135 {
7136 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
7137 d.vkResetQueryPool( static_cast<VkDevice>( m_device ), static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount );
7138 }
7139
7140 // wrapper function for command vkGetSemaphoreCounterValue, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreCounterValue.html
7141 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
7142 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSemaphoreCounterValue( Semaphore semaphore,
7143 uint64_t * pValue,
7144 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
7145 {
7146 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
7147 return static_cast<Result>( d.vkGetSemaphoreCounterValue( static_cast<VkDevice>( m_device ), static_cast<VkSemaphore>( semaphore ), pValue ) );
7148 }
7149
7150 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7151 // wrapper function for command vkGetSemaphoreCounterValue, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreCounterValue.html
7152 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
7153 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<uint64_t>::type Device::getSemaphoreCounterValue( Semaphore semaphore,
7154 Dispatch const & d ) const
7155 {
7156 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
7157 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
7158 VULKAN_HPP_ASSERT( d.vkGetSemaphoreCounterValue && "Function <vkGetSemaphoreCounterValue> requires <VK_KHR_timeline_semaphore> or <VK_VERSION_1_2>" );
7159 # endif
7160
7161 uint64_t value;
7162 Result result = static_cast<Result>( d.vkGetSemaphoreCounterValue( m_device, static_cast<VkSemaphore>( semaphore ), &value ) );
7163 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreCounterValue" );
7164
7165 return detail::createResultValueType( result, std::move( value ) );
7166 }
7167 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7168
7169 // wrapper function for command vkWaitSemaphores, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitSemaphores.html
7170 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
7171 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::waitSemaphores( const SemaphoreWaitInfo * pWaitInfo,
7172 uint64_t timeout,
7173 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
7174 {
7175 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
7176 return static_cast<Result>( d.vkWaitSemaphores( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkSemaphoreWaitInfo *>( pWaitInfo ), timeout ) );
7177 }
7178
7179 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7180 // wrapper function for command vkWaitSemaphores, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitSemaphores.html
7181 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
7182 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::waitSemaphores( const SemaphoreWaitInfo & waitInfo, uint64_t timeout, Dispatch const & d ) const
7183 {
7184 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
7185 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
7186 VULKAN_HPP_ASSERT( d.vkWaitSemaphores && "Function <vkWaitSemaphores> requires <VK_KHR_timeline_semaphore> or <VK_VERSION_1_2>" );
7187 # endif
7188
7189 Result result = static_cast<Result>( d.vkWaitSemaphores( m_device, reinterpret_cast<const VkSemaphoreWaitInfo *>( &waitInfo ), timeout ) );
7190 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::waitSemaphores", { Result::eSuccess, Result::eTimeout } );
7191
7192 return static_cast<Result>( result );
7193 }
7194 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7195
7196 // wrapper function for command vkSignalSemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSignalSemaphore.html
7197 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
7198 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::signalSemaphore( const SemaphoreSignalInfo * pSignalInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
7199 {
7200 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
7201 return static_cast<Result>( d.vkSignalSemaphore( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkSemaphoreSignalInfo *>( pSignalInfo ) ) );
7202 }
7203
7204 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7205 // wrapper function for command vkSignalSemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSignalSemaphore.html
7206 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
7207 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
7208 Device::signalSemaphore( const SemaphoreSignalInfo & signalInfo, Dispatch const & d ) const
7209 {
7210 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
7211 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
7212 VULKAN_HPP_ASSERT( d.vkSignalSemaphore && "Function <vkSignalSemaphore> requires <VK_KHR_timeline_semaphore> or <VK_VERSION_1_2>" );
7213 # endif
7214
7215 Result result = static_cast<Result>( d.vkSignalSemaphore( m_device, reinterpret_cast<const VkSemaphoreSignalInfo *>( &signalInfo ) ) );
7216 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::signalSemaphore" );
7217
7218 return detail::createResultValueType( result );
7219 }
7220 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7221
7222 // wrapper function for command vkGetBufferDeviceAddress, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferDeviceAddress.html
7223 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
7224 VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddress( const BufferDeviceAddressInfo * pInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
7225 {
7226 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
7227 return static_cast<DeviceAddress>(
7228 d.vkGetBufferDeviceAddress( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkBufferDeviceAddressInfo *>( pInfo ) ) );
7229 }
7230
7231 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7232 // wrapper function for command vkGetBufferDeviceAddress, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferDeviceAddress.html
7233 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
7234 VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddress( const BufferDeviceAddressInfo & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
7235 {
7236 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
7237 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
7238 VULKAN_HPP_ASSERT( d.vkGetBufferDeviceAddress &&
7239 "Function <vkGetBufferDeviceAddress> requires <VK_EXT_buffer_device_address> or <VK_KHR_buffer_device_address> or <VK_VERSION_1_2>" );
7240 # endif
7241
7242 VkDeviceAddress result = d.vkGetBufferDeviceAddress( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo *>( &info ) );
7243
7244 return static_cast<DeviceAddress>( result );
7245 }
7246 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7247
7248 // wrapper function for command vkGetBufferOpaqueCaptureAddress, see
7249 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferOpaqueCaptureAddress.html
7250 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
7251 VULKAN_HPP_INLINE uint64_t Device::getBufferOpaqueCaptureAddress( const BufferDeviceAddressInfo * pInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
7252 {
7253 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
7254 return d.vkGetBufferOpaqueCaptureAddress( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkBufferDeviceAddressInfo *>( pInfo ) );
7255 }
7256
7257 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7258 // wrapper function for command vkGetBufferOpaqueCaptureAddress, see
7259 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferOpaqueCaptureAddress.html
7260 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
7261 VULKAN_HPP_INLINE uint64_t Device::getBufferOpaqueCaptureAddress( const BufferDeviceAddressInfo & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
7262 {
7263 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
7264 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
7265 VULKAN_HPP_ASSERT( d.vkGetBufferOpaqueCaptureAddress &&
7266 "Function <vkGetBufferOpaqueCaptureAddress> requires <VK_KHR_buffer_device_address> or <VK_VERSION_1_2>" );
7267 # endif
7268
7269 uint64_t result = d.vkGetBufferOpaqueCaptureAddress( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo *>( &info ) );
7270
7271 return result;
7272 }
7273 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7274
7275 // wrapper function for command vkGetDeviceMemoryOpaqueCaptureAddress, see
7276 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMemoryOpaqueCaptureAddress.html
7277 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
7278 VULKAN_HPP_INLINE uint64_t Device::getMemoryOpaqueCaptureAddress( const DeviceMemoryOpaqueCaptureAddressInfo * pInfo,
7279 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
7280 {
7281 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
7282 return d.vkGetDeviceMemoryOpaqueCaptureAddress( static_cast<VkDevice>( m_device ),
7283 reinterpret_cast<const VkDeviceMemoryOpaqueCaptureAddressInfo *>( pInfo ) );
7284 }
7285
7286 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7287 // wrapper function for command vkGetDeviceMemoryOpaqueCaptureAddress, see
7288 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMemoryOpaqueCaptureAddress.html
7289 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
7290 VULKAN_HPP_INLINE uint64_t Device::getMemoryOpaqueCaptureAddress( const DeviceMemoryOpaqueCaptureAddressInfo & info,
7291 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
7292 {
7293 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
7294 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
7295 VULKAN_HPP_ASSERT( d.vkGetDeviceMemoryOpaqueCaptureAddress &&
7296 "Function <vkGetDeviceMemoryOpaqueCaptureAddress> requires <VK_KHR_buffer_device_address> or <VK_VERSION_1_2>" );
7297 # endif
7298
7299 uint64_t result = d.vkGetDeviceMemoryOpaqueCaptureAddress( m_device, reinterpret_cast<const VkDeviceMemoryOpaqueCaptureAddressInfo *>( &info ) );
7300
7301 return result;
7302 }
7303 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7304
7305 // wrapper function for command vkCmdDrawIndirectCount, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirectCount.html
7306 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
7307 VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCount( Buffer buffer,
7308 DeviceSize offset,
7309 Buffer countBuffer,
7310 DeviceSize countBufferOffset,
7311 uint32_t maxDrawCount,
7312 uint32_t stride,
7313 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
7314 {
7315 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
7316 d.vkCmdDrawIndirectCount( static_cast<VkCommandBuffer>( m_commandBuffer ),
7317 static_cast<VkBuffer>( buffer ),
7318 static_cast<VkDeviceSize>( offset ),
7319 static_cast<VkBuffer>( countBuffer ),
7320 static_cast<VkDeviceSize>( countBufferOffset ),
7321 maxDrawCount,
7322 stride );
7323 }
7324
7325 // wrapper function for command vkCmdDrawIndexedIndirectCount, see
7326 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexedIndirectCount.html
7327 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
7328 VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCount( Buffer buffer,
7329 DeviceSize offset,
7330 Buffer countBuffer,
7331 DeviceSize countBufferOffset,
7332 uint32_t maxDrawCount,
7333 uint32_t stride,
7334 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
7335 {
7336 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
7337 d.vkCmdDrawIndexedIndirectCount( static_cast<VkCommandBuffer>( m_commandBuffer ),
7338 static_cast<VkBuffer>( buffer ),
7339 static_cast<VkDeviceSize>( offset ),
7340 static_cast<VkBuffer>( countBuffer ),
7341 static_cast<VkDeviceSize>( countBufferOffset ),
7342 maxDrawCount,
7343 stride );
7344 }
7345
7346 // wrapper function for command vkCreateRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass2.html
7347 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
7348 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createRenderPass2( const RenderPassCreateInfo2 * pCreateInfo,
7349 const AllocationCallbacks * pAllocator,
7350 RenderPass * pRenderPass,
7351 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
7352 {
7353 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
7354 return static_cast<Result>( d.vkCreateRenderPass2( static_cast<VkDevice>( m_device ),
7355 reinterpret_cast<const VkRenderPassCreateInfo2 *>( pCreateInfo ),
7356 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
7357 reinterpret_cast<VkRenderPass *>( pRenderPass ) ) );
7358 }
7359
7360 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7361 // wrapper function for command vkCreateRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass2.html
7362 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
7363 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<RenderPass>::type
7364 Device::createRenderPass2( const RenderPassCreateInfo2 & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
7365 {
7366 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
7367 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
7368 VULKAN_HPP_ASSERT( d.vkCreateRenderPass2 && "Function <vkCreateRenderPass2> requires <VK_KHR_create_renderpass2> or <VK_VERSION_1_2>" );
7369 # endif
7370
7371 RenderPass renderPass;
7372 Result result = static_cast<Result>( d.vkCreateRenderPass2( m_device,
7373 reinterpret_cast<const VkRenderPassCreateInfo2 *>( &createInfo ),
7374 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
7375 reinterpret_cast<VkRenderPass *>( &renderPass ) ) );
7376 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPass2" );
7377
7378 return detail::createResultValueType( result, std::move( renderPass ) );
7379 }
7380
7381 # ifndef VULKAN_HPP_NO_SMART_HANDLE
7382 // wrapper function for command vkCreateRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass2.html
7383 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
7384 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<RenderPass, Dispatch>>::type
7385 Device::createRenderPass2Unique( const RenderPassCreateInfo2 & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
7386 {
7387 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
7388 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
7389 VULKAN_HPP_ASSERT( d.vkCreateRenderPass2 && "Function <vkCreateRenderPass2> requires <VK_KHR_create_renderpass2> or <VK_VERSION_1_2>" );
7390 # endif
7391
7392 RenderPass renderPass;
7393 Result result = static_cast<Result>( d.vkCreateRenderPass2( m_device,
7394 reinterpret_cast<const VkRenderPassCreateInfo2 *>( &createInfo ),
7395 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
7396 reinterpret_cast<VkRenderPass *>( &renderPass ) ) );
7397 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPass2Unique" );
7398
7399 return detail::createResultValueType( result,
7400 UniqueHandle<RenderPass, Dispatch>( renderPass, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
7401 }
7402 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
7403 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7404
7405 // wrapper function for command vkCmdBeginRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderPass2.html
7406 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
7407 VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass2( const RenderPassBeginInfo * pRenderPassBegin,
7408 const SubpassBeginInfo * pSubpassBeginInfo,
7409 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
7410 {
7411 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
7412 d.vkCmdBeginRenderPass2( static_cast<VkCommandBuffer>( m_commandBuffer ),
7413 reinterpret_cast<const VkRenderPassBeginInfo *>( pRenderPassBegin ),
7414 reinterpret_cast<const VkSubpassBeginInfo *>( pSubpassBeginInfo ) );
7415 }
7416
7417 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7418 // wrapper function for command vkCmdBeginRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderPass2.html
7419 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
7420 VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass2( const RenderPassBeginInfo & renderPassBegin,
7421 const SubpassBeginInfo & subpassBeginInfo,
7422 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
7423 {
7424 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
7425 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
7426 VULKAN_HPP_ASSERT( d.vkCmdBeginRenderPass2 && "Function <vkCmdBeginRenderPass2> requires <VK_KHR_create_renderpass2> or <VK_VERSION_1_2>" );
7427 # endif
7428
7429 d.vkCmdBeginRenderPass2(
7430 m_commandBuffer, reinterpret_cast<const VkRenderPassBeginInfo *>( &renderPassBegin ), reinterpret_cast<const VkSubpassBeginInfo *>( &subpassBeginInfo ) );
7431 }
7432 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7433
7434 // wrapper function for command vkCmdNextSubpass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdNextSubpass2.html
7435 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
7436 VULKAN_HPP_INLINE void CommandBuffer::nextSubpass2( const SubpassBeginInfo * pSubpassBeginInfo,
7437 const SubpassEndInfo * pSubpassEndInfo,
7438 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
7439 {
7440 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
7441 d.vkCmdNextSubpass2( static_cast<VkCommandBuffer>( m_commandBuffer ),
7442 reinterpret_cast<const VkSubpassBeginInfo *>( pSubpassBeginInfo ),
7443 reinterpret_cast<const VkSubpassEndInfo *>( pSubpassEndInfo ) );
7444 }
7445
7446 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7447 // wrapper function for command vkCmdNextSubpass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdNextSubpass2.html
7448 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
7449 VULKAN_HPP_INLINE void CommandBuffer::nextSubpass2( const SubpassBeginInfo & subpassBeginInfo,
7450 const SubpassEndInfo & subpassEndInfo,
7451 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
7452 {
7453 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
7454 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
7455 VULKAN_HPP_ASSERT( d.vkCmdNextSubpass2 && "Function <vkCmdNextSubpass2> requires <VK_KHR_create_renderpass2> or <VK_VERSION_1_2>" );
7456 # endif
7457
7458 d.vkCmdNextSubpass2(
7459 m_commandBuffer, reinterpret_cast<const VkSubpassBeginInfo *>( &subpassBeginInfo ), reinterpret_cast<const VkSubpassEndInfo *>( &subpassEndInfo ) );
7460 }
7461 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7462
7463 // wrapper function for command vkCmdEndRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderPass2.html
7464 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
7465 VULKAN_HPP_INLINE void CommandBuffer::endRenderPass2( const SubpassEndInfo * pSubpassEndInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
7466 {
7467 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
7468 d.vkCmdEndRenderPass2( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkSubpassEndInfo *>( pSubpassEndInfo ) );
7469 }
7470
7471 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7472 // wrapper function for command vkCmdEndRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderPass2.html
7473 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
7474 VULKAN_HPP_INLINE void CommandBuffer::endRenderPass2( const SubpassEndInfo & subpassEndInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
7475 {
7476 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
7477 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
7478 VULKAN_HPP_ASSERT( d.vkCmdEndRenderPass2 && "Function <vkCmdEndRenderPass2> requires <VK_KHR_create_renderpass2> or <VK_VERSION_1_2>" );
7479 # endif
7480
7481 d.vkCmdEndRenderPass2( m_commandBuffer, reinterpret_cast<const VkSubpassEndInfo *>( &subpassEndInfo ) );
7482 }
7483 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7484
7485 //=== VK_VERSION_1_3 ===
7486
7487 // wrapper function for command vkGetPhysicalDeviceToolProperties, see
7488 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceToolProperties.html
7489 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
7490 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getToolProperties( uint32_t * pToolCount,
7491 PhysicalDeviceToolProperties * pToolProperties,
7492 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
7493 {
7494 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
7495 return static_cast<Result>( d.vkGetPhysicalDeviceToolProperties(
7496 static_cast<VkPhysicalDevice>( m_physicalDevice ), pToolCount, reinterpret_cast<VkPhysicalDeviceToolProperties *>( pToolProperties ) ) );
7497 }
7498
7499 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7500 // wrapper function for command vkGetPhysicalDeviceToolProperties, see
7501 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceToolProperties.html
7502 template <typename PhysicalDeviceToolPropertiesAllocator,
7503 typename Dispatch,
7504 typename std::enable_if<std::is_same<typename PhysicalDeviceToolPropertiesAllocator::value_type, PhysicalDeviceToolProperties>::value, int>::type,
7505 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
7506 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator>>::type
7507 PhysicalDevice::getToolProperties( Dispatch const & d ) const
7508 {
7509 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
7510 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
7511 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceToolProperties &&
7512 "Function <vkGetPhysicalDeviceToolProperties> requires <VK_EXT_tooling_info> or <VK_VERSION_1_3>" );
7513 # endif
7514
7515 std::vector<PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator> toolProperties;
7516 uint32_t toolCount;
7517 Result result;
7518 do
7519 {
7520 result = static_cast<Result>( d.vkGetPhysicalDeviceToolProperties( m_physicalDevice, &toolCount, nullptr ) );
7521 if ( ( result == Result::eSuccess ) && toolCount )
7522 {
7523 toolProperties.resize( toolCount );
7524 result = static_cast<Result>(
7525 d.vkGetPhysicalDeviceToolProperties( m_physicalDevice, &toolCount, reinterpret_cast<VkPhysicalDeviceToolProperties *>( toolProperties.data() ) ) );
7526 }
7527 } while ( result == Result::eIncomplete );
7528 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getToolProperties" );
7529 VULKAN_HPP_ASSERT( toolCount <= toolProperties.size() );
7530 if ( toolCount < toolProperties.size() )
7531 {
7532 toolProperties.resize( toolCount );
7533 }
7534 return detail::createResultValueType( result, std::move( toolProperties ) );
7535 }
7536
7537 // wrapper function for command vkGetPhysicalDeviceToolProperties, see
7538 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceToolProperties.html
7539 template <typename PhysicalDeviceToolPropertiesAllocator,
7540 typename Dispatch,
7541 typename std::enable_if<std::is_same<typename PhysicalDeviceToolPropertiesAllocator::value_type, PhysicalDeviceToolProperties>::value, int>::type,
7542 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
7543 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator>>::type
7544 PhysicalDevice::getToolProperties( PhysicalDeviceToolPropertiesAllocator & physicalDeviceToolPropertiesAllocator, Dispatch const & d ) const
7545 {
7546 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
7547 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
7548 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceToolProperties &&
7549 "Function <vkGetPhysicalDeviceToolProperties> requires <VK_EXT_tooling_info> or <VK_VERSION_1_3>" );
7550 # endif
7551
7552 std::vector<PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator> toolProperties( physicalDeviceToolPropertiesAllocator );
7553 uint32_t toolCount;
7554 Result result;
7555 do
7556 {
7557 result = static_cast<Result>( d.vkGetPhysicalDeviceToolProperties( m_physicalDevice, &toolCount, nullptr ) );
7558 if ( ( result == Result::eSuccess ) && toolCount )
7559 {
7560 toolProperties.resize( toolCount );
7561 result = static_cast<Result>(
7562 d.vkGetPhysicalDeviceToolProperties( m_physicalDevice, &toolCount, reinterpret_cast<VkPhysicalDeviceToolProperties *>( toolProperties.data() ) ) );
7563 }
7564 } while ( result == Result::eIncomplete );
7565 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getToolProperties" );
7566 VULKAN_HPP_ASSERT( toolCount <= toolProperties.size() );
7567 if ( toolCount < toolProperties.size() )
7568 {
7569 toolProperties.resize( toolCount );
7570 }
7571 return detail::createResultValueType( result, std::move( toolProperties ) );
7572 }
7573 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7574
7575 // wrapper function for command vkCreatePrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePrivateDataSlot.html
7576 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
7577 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createPrivateDataSlot( const PrivateDataSlotCreateInfo * pCreateInfo,
7578 const AllocationCallbacks * pAllocator,
7579 PrivateDataSlot * pPrivateDataSlot,
7580 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
7581 {
7582 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
7583 return static_cast<Result>( d.vkCreatePrivateDataSlot( static_cast<VkDevice>( m_device ),
7584 reinterpret_cast<const VkPrivateDataSlotCreateInfo *>( pCreateInfo ),
7585 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
7586 reinterpret_cast<VkPrivateDataSlot *>( pPrivateDataSlot ) ) );
7587 }
7588
7589 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7590 // wrapper function for command vkCreatePrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePrivateDataSlot.html
7591 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
7592 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<PrivateDataSlot>::type
7593 Device::createPrivateDataSlot( const PrivateDataSlotCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
7594 {
7595 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
7596 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
7597 VULKAN_HPP_ASSERT( d.vkCreatePrivateDataSlot && "Function <vkCreatePrivateDataSlot> requires <VK_EXT_private_data> or <VK_VERSION_1_3>" );
7598 # endif
7599
7600 PrivateDataSlot privateDataSlot;
7601 Result result = static_cast<Result>( d.vkCreatePrivateDataSlot( m_device,
7602 reinterpret_cast<const VkPrivateDataSlotCreateInfo *>( &createInfo ),
7603 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
7604 reinterpret_cast<VkPrivateDataSlot *>( &privateDataSlot ) ) );
7605 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createPrivateDataSlot" );
7606
7607 return detail::createResultValueType( result, std::move( privateDataSlot ) );
7608 }
7609
7610 # ifndef VULKAN_HPP_NO_SMART_HANDLE
7611 // wrapper function for command vkCreatePrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePrivateDataSlot.html
7612 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
7613 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<PrivateDataSlot, Dispatch>>::type
7614 Device::createPrivateDataSlotUnique( const PrivateDataSlotCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
7615 {
7616 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
7617 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
7618 VULKAN_HPP_ASSERT( d.vkCreatePrivateDataSlot && "Function <vkCreatePrivateDataSlot> requires <VK_EXT_private_data> or <VK_VERSION_1_3>" );
7619 # endif
7620
7621 PrivateDataSlot privateDataSlot;
7622 Result result = static_cast<Result>( d.vkCreatePrivateDataSlot( m_device,
7623 reinterpret_cast<const VkPrivateDataSlotCreateInfo *>( &createInfo ),
7624 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
7625 reinterpret_cast<VkPrivateDataSlot *>( &privateDataSlot ) ) );
7626 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createPrivateDataSlotUnique" );
7627
7628 return detail::createResultValueType(
7629 result, UniqueHandle<PrivateDataSlot, Dispatch>( privateDataSlot, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
7630 }
7631 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
7632 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7633
7634 // wrapper function for command vkDestroyPrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPrivateDataSlot.html
7635 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
7636 VULKAN_HPP_INLINE void
7637 Device::destroyPrivateDataSlot( PrivateDataSlot privateDataSlot, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
7638 {
7639 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
7640 d.vkDestroyPrivateDataSlot(
7641 static_cast<VkDevice>( m_device ), static_cast<VkPrivateDataSlot>( privateDataSlot ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
7642 }
7643
7644 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7645 // wrapper function for command vkDestroyPrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPrivateDataSlot.html
7646 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
7647 VULKAN_HPP_INLINE void Device::destroyPrivateDataSlot( PrivateDataSlot privateDataSlot,
7648 Optional<const AllocationCallbacks> allocator,
7649 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
7650 {
7651 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
7652 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
7653 VULKAN_HPP_ASSERT( d.vkDestroyPrivateDataSlot && "Function <vkDestroyPrivateDataSlot> requires <VK_EXT_private_data> or <VK_VERSION_1_3>" );
7654 # endif
7655
7656 d.vkDestroyPrivateDataSlot(
7657 m_device, static_cast<VkPrivateDataSlot>( privateDataSlot ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
7658 }
7659 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7660
7661 // wrapper function for command vkDestroyPrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPrivateDataSlot.html
7662 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
7663 VULKAN_HPP_INLINE void
7664 Device::destroy( PrivateDataSlot privateDataSlot, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
7665 {
7666 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
7667 d.vkDestroyPrivateDataSlot(
7668 static_cast<VkDevice>( m_device ), static_cast<VkPrivateDataSlot>( privateDataSlot ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
7669 }
7670
7671 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7672 // wrapper function for command vkDestroyPrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPrivateDataSlot.html
7673 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
7674 VULKAN_HPP_INLINE void
7675 Device::destroy( PrivateDataSlot privateDataSlot, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
7676 {
7677 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
7678 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
7679 VULKAN_HPP_ASSERT( d.vkDestroyPrivateDataSlot && "Function <vkDestroyPrivateDataSlot> requires <VK_EXT_private_data> or <VK_VERSION_1_3>" );
7680 # endif
7681
7682 d.vkDestroyPrivateDataSlot(
7683 m_device, static_cast<VkPrivateDataSlot>( privateDataSlot ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
7684 }
7685 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7686
7687 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
7688 // wrapper function for command vkSetPrivateData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetPrivateData.html
7689 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
7690 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::setPrivateData(
7691 ObjectType objectType_, uint64_t objectHandle, PrivateDataSlot privateDataSlot, uint64_t data, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
7692 {
7693 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
7694 return static_cast<Result>( d.vkSetPrivateData(
7695 static_cast<VkDevice>( m_device ), static_cast<VkObjectType>( objectType_ ), objectHandle, static_cast<VkPrivateDataSlot>( privateDataSlot ), data ) );
7696 }
7697 #else
7698 // wrapper function for command vkSetPrivateData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetPrivateData.html
7699 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
7700 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
7701 Device::setPrivateData( ObjectType objectType_, uint64_t objectHandle, PrivateDataSlot privateDataSlot, uint64_t data, Dispatch const & d ) const
7702 {
7703 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
7704 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
7705 VULKAN_HPP_ASSERT( d.vkSetPrivateData && "Function <vkSetPrivateData> requires <VK_EXT_private_data> or <VK_VERSION_1_3>" );
7706 # endif
7707
7708 Result result = static_cast<Result>(
7709 d.vkSetPrivateData( m_device, static_cast<VkObjectType>( objectType_ ), objectHandle, static_cast<VkPrivateDataSlot>( privateDataSlot ), data ) );
7710 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setPrivateData" );
7711
7712 return detail::createResultValueType( result );
7713 }
7714 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7715
7716 // wrapper function for command vkGetPrivateData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPrivateData.html
7717 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
7718 VULKAN_HPP_INLINE void Device::getPrivateData(
7719 ObjectType objectType_, uint64_t objectHandle, PrivateDataSlot privateDataSlot, uint64_t * pData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
7720 {
7721 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
7722 d.vkGetPrivateData(
7723 static_cast<VkDevice>( m_device ), static_cast<VkObjectType>( objectType_ ), objectHandle, static_cast<VkPrivateDataSlot>( privateDataSlot ), pData );
7724 }
7725
7726 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7727 // wrapper function for command vkGetPrivateData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPrivateData.html
7728 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
7729 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t
7730 Device::getPrivateData( ObjectType objectType_, uint64_t objectHandle, PrivateDataSlot privateDataSlot, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
7731 {
7732 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
7733 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
7734 VULKAN_HPP_ASSERT( d.vkGetPrivateData && "Function <vkGetPrivateData> requires <VK_EXT_private_data> or <VK_VERSION_1_3>" );
7735 # endif
7736
7737 uint64_t data;
7738 d.vkGetPrivateData( m_device, static_cast<VkObjectType>( objectType_ ), objectHandle, static_cast<VkPrivateDataSlot>( privateDataSlot ), &data );
7739
7740 return data;
7741 }
7742 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7743
7744 // wrapper function for command vkCmdPipelineBarrier2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPipelineBarrier2.html
7745 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
7746 VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier2( const DependencyInfo * pDependencyInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
7747 {
7748 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
7749 d.vkCmdPipelineBarrier2( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkDependencyInfo *>( pDependencyInfo ) );
7750 }
7751
7752 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7753 // wrapper function for command vkCmdPipelineBarrier2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPipelineBarrier2.html
7754 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
7755 VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier2( const DependencyInfo & dependencyInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
7756 {
7757 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
7758 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
7759 VULKAN_HPP_ASSERT( d.vkCmdPipelineBarrier2 && "Function <vkCmdPipelineBarrier2> requires <VK_KHR_synchronization2> or <VK_VERSION_1_3>" );
7760 # endif
7761
7762 d.vkCmdPipelineBarrier2( m_commandBuffer, reinterpret_cast<const VkDependencyInfo *>( &dependencyInfo ) );
7763 }
7764 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7765
7766 // wrapper function for command vkCmdWriteTimestamp2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteTimestamp2.html
7767 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
7768 VULKAN_HPP_INLINE void
7769 CommandBuffer::writeTimestamp2( PipelineStageFlags2 stage, QueryPool queryPool, uint32_t query, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
7770 {
7771 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
7772 d.vkCmdWriteTimestamp2(
7773 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkPipelineStageFlags2>( stage ), static_cast<VkQueryPool>( queryPool ), query );
7774 }
7775
7776 // wrapper function for command vkQueueSubmit2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSubmit2.html
7777 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
7778 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
7779 Queue::submit2( uint32_t submitCount, const SubmitInfo2 * pSubmits, Fence fence, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
7780 {
7781 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
7782 return static_cast<Result>(
7783 d.vkQueueSubmit2( static_cast<VkQueue>( m_queue ), submitCount, reinterpret_cast<const VkSubmitInfo2 *>( pSubmits ), static_cast<VkFence>( fence ) ) );
7784 }
7785
7786 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7787 // wrapper function for command vkQueueSubmit2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSubmit2.html
7788 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
7789 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
7790 Queue::submit2( ArrayProxy<const SubmitInfo2> const & submits, Fence fence, Dispatch const & d ) const
7791 {
7792 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
7793 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
7794 VULKAN_HPP_ASSERT( d.vkQueueSubmit2 && "Function <vkQueueSubmit2> requires <VK_KHR_synchronization2> or <VK_VERSION_1_3>" );
7795 # endif
7796
7797 Result result = static_cast<Result>(
7798 d.vkQueueSubmit2( m_queue, submits.size(), reinterpret_cast<const VkSubmitInfo2 *>( submits.data() ), static_cast<VkFence>( fence ) ) );
7799 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::submit2" );
7800
7801 return detail::createResultValueType( result );
7802 }
7803 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7804
7805 // wrapper function for command vkCmdCopyBuffer2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBuffer2.html
7806 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
7807 VULKAN_HPP_INLINE void CommandBuffer::copyBuffer2( const CopyBufferInfo2 * pCopyBufferInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
7808 {
7809 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
7810 d.vkCmdCopyBuffer2( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkCopyBufferInfo2 *>( pCopyBufferInfo ) );
7811 }
7812
7813 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7814 // wrapper function for command vkCmdCopyBuffer2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBuffer2.html
7815 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
7816 VULKAN_HPP_INLINE void CommandBuffer::copyBuffer2( const CopyBufferInfo2 & copyBufferInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
7817 {
7818 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
7819 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
7820 VULKAN_HPP_ASSERT( d.vkCmdCopyBuffer2 && "Function <vkCmdCopyBuffer2> requires <VK_KHR_copy_commands2> or <VK_VERSION_1_3>" );
7821 # endif
7822
7823 d.vkCmdCopyBuffer2( m_commandBuffer, reinterpret_cast<const VkCopyBufferInfo2 *>( &copyBufferInfo ) );
7824 }
7825 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7826
7827 // wrapper function for command vkCmdCopyImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImage2.html
7828 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
7829 VULKAN_HPP_INLINE void CommandBuffer::copyImage2( const CopyImageInfo2 * pCopyImageInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
7830 {
7831 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
7832 d.vkCmdCopyImage2( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkCopyImageInfo2 *>( pCopyImageInfo ) );
7833 }
7834
7835 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7836 // wrapper function for command vkCmdCopyImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImage2.html
7837 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
7838 VULKAN_HPP_INLINE void CommandBuffer::copyImage2( const CopyImageInfo2 & copyImageInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
7839 {
7840 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
7841 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
7842 VULKAN_HPP_ASSERT( d.vkCmdCopyImage2 && "Function <vkCmdCopyImage2> requires <VK_KHR_copy_commands2> or <VK_VERSION_1_3>" );
7843 # endif
7844
7845 d.vkCmdCopyImage2( m_commandBuffer, reinterpret_cast<const VkCopyImageInfo2 *>( &copyImageInfo ) );
7846 }
7847 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7848
7849 // wrapper function for command vkCmdCopyBufferToImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBufferToImage2.html
7850 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
7851 VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage2( const CopyBufferToImageInfo2 * pCopyBufferToImageInfo,
7852 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
7853 {
7854 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
7855 d.vkCmdCopyBufferToImage2( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkCopyBufferToImageInfo2 *>( pCopyBufferToImageInfo ) );
7856 }
7857
7858 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7859 // wrapper function for command vkCmdCopyBufferToImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBufferToImage2.html
7860 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
7861 VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage2( const CopyBufferToImageInfo2 & copyBufferToImageInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
7862 {
7863 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
7864 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
7865 VULKAN_HPP_ASSERT( d.vkCmdCopyBufferToImage2 && "Function <vkCmdCopyBufferToImage2> requires <VK_KHR_copy_commands2> or <VK_VERSION_1_3>" );
7866 # endif
7867
7868 d.vkCmdCopyBufferToImage2( m_commandBuffer, reinterpret_cast<const VkCopyBufferToImageInfo2 *>( &copyBufferToImageInfo ) );
7869 }
7870 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7871
7872 // wrapper function for command vkCmdCopyImageToBuffer2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToBuffer2.html
7873 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
7874 VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer2( const CopyImageToBufferInfo2 * pCopyImageToBufferInfo,
7875 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
7876 {
7877 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
7878 d.vkCmdCopyImageToBuffer2( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkCopyImageToBufferInfo2 *>( pCopyImageToBufferInfo ) );
7879 }
7880
7881 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7882 // wrapper function for command vkCmdCopyImageToBuffer2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToBuffer2.html
7883 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
7884 VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer2( const CopyImageToBufferInfo2 & copyImageToBufferInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
7885 {
7886 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
7887 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
7888 VULKAN_HPP_ASSERT( d.vkCmdCopyImageToBuffer2 && "Function <vkCmdCopyImageToBuffer2> requires <VK_KHR_copy_commands2> or <VK_VERSION_1_3>" );
7889 # endif
7890
7891 d.vkCmdCopyImageToBuffer2( m_commandBuffer, reinterpret_cast<const VkCopyImageToBufferInfo2 *>( &copyImageToBufferInfo ) );
7892 }
7893 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7894
7895 // wrapper function for command vkGetDeviceBufferMemoryRequirements, see
7896 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceBufferMemoryRequirements.html
7897 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
7898 VULKAN_HPP_INLINE void Device::getBufferMemoryRequirements( const DeviceBufferMemoryRequirements * pInfo,
7899 MemoryRequirements2 * pMemoryRequirements,
7900 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
7901 {
7902 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
7903 d.vkGetDeviceBufferMemoryRequirements( static_cast<VkDevice>( m_device ),
7904 reinterpret_cast<const VkDeviceBufferMemoryRequirements *>( pInfo ),
7905 reinterpret_cast<VkMemoryRequirements2 *>( pMemoryRequirements ) );
7906 }
7907
7908 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7909 // wrapper function for command vkGetDeviceBufferMemoryRequirements, see
7910 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceBufferMemoryRequirements.html
7911 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
7912 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 Device::getBufferMemoryRequirements( const DeviceBufferMemoryRequirements & info,
7913 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
7914 {
7915 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
7916 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
7917 VULKAN_HPP_ASSERT( d.vkGetDeviceBufferMemoryRequirements &&
7918 "Function <vkGetDeviceBufferMemoryRequirements> requires <VK_KHR_maintenance4> or <VK_VERSION_1_3>" );
7919 # endif
7920
7921 MemoryRequirements2 memoryRequirements;
7922 d.vkGetDeviceBufferMemoryRequirements(
7923 m_device, reinterpret_cast<const VkDeviceBufferMemoryRequirements *>( &info ), reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
7924
7925 return memoryRequirements;
7926 }
7927
7928 // wrapper function for command vkGetDeviceBufferMemoryRequirements, see
7929 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceBufferMemoryRequirements.html
7930 template <typename X, typename Y, typename... Z, typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
7931 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getBufferMemoryRequirements( const DeviceBufferMemoryRequirements & info,
7932 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
7933 {
7934 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
7935 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
7936 VULKAN_HPP_ASSERT( d.vkGetDeviceBufferMemoryRequirements &&
7937 "Function <vkGetDeviceBufferMemoryRequirements> requires <VK_KHR_maintenance4> or <VK_VERSION_1_3>" );
7938 # endif
7939
7940 StructureChain<X, Y, Z...> structureChain;
7941 MemoryRequirements2 & memoryRequirements = structureChain.template get<MemoryRequirements2>();
7942 d.vkGetDeviceBufferMemoryRequirements(
7943 m_device, reinterpret_cast<const VkDeviceBufferMemoryRequirements *>( &info ), reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
7944
7945 return structureChain;
7946 }
7947 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7948
7949 // wrapper function for command vkGetDeviceImageMemoryRequirements, see
7950 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageMemoryRequirements.html
7951 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
7952 VULKAN_HPP_INLINE void Device::getImageMemoryRequirements( const DeviceImageMemoryRequirements * pInfo,
7953 MemoryRequirements2 * pMemoryRequirements,
7954 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
7955 {
7956 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
7957 d.vkGetDeviceImageMemoryRequirements( static_cast<VkDevice>( m_device ),
7958 reinterpret_cast<const VkDeviceImageMemoryRequirements *>( pInfo ),
7959 reinterpret_cast<VkMemoryRequirements2 *>( pMemoryRequirements ) );
7960 }
7961
7962 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7963 // wrapper function for command vkGetDeviceImageMemoryRequirements, see
7964 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageMemoryRequirements.html
7965 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
7966 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 Device::getImageMemoryRequirements( const DeviceImageMemoryRequirements & info,
7967 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
7968 {
7969 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
7970 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
7971 VULKAN_HPP_ASSERT( d.vkGetDeviceImageMemoryRequirements &&
7972 "Function <vkGetDeviceImageMemoryRequirements> requires <VK_KHR_maintenance4> or <VK_VERSION_1_3>" );
7973 # endif
7974
7975 MemoryRequirements2 memoryRequirements;
7976 d.vkGetDeviceImageMemoryRequirements(
7977 m_device, reinterpret_cast<const VkDeviceImageMemoryRequirements *>( &info ), reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
7978
7979 return memoryRequirements;
7980 }
7981
7982 // wrapper function for command vkGetDeviceImageMemoryRequirements, see
7983 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageMemoryRequirements.html
7984 template <typename X, typename Y, typename... Z, typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
7985 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getImageMemoryRequirements( const DeviceImageMemoryRequirements & info,
7986 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
7987 {
7988 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
7989 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
7990 VULKAN_HPP_ASSERT( d.vkGetDeviceImageMemoryRequirements &&
7991 "Function <vkGetDeviceImageMemoryRequirements> requires <VK_KHR_maintenance4> or <VK_VERSION_1_3>" );
7992 # endif
7993
7994 StructureChain<X, Y, Z...> structureChain;
7995 MemoryRequirements2 & memoryRequirements = structureChain.template get<MemoryRequirements2>();
7996 d.vkGetDeviceImageMemoryRequirements(
7997 m_device, reinterpret_cast<const VkDeviceImageMemoryRequirements *>( &info ), reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
7998
7999 return structureChain;
8000 }
8001 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8002
8003 // wrapper function for command vkGetDeviceImageSparseMemoryRequirements, see
8004 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSparseMemoryRequirements.html
8005 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8006 VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirements( const DeviceImageMemoryRequirements * pInfo,
8007 uint32_t * pSparseMemoryRequirementCount,
8008 SparseImageMemoryRequirements2 * pSparseMemoryRequirements,
8009 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
8010 {
8011 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8012 d.vkGetDeviceImageSparseMemoryRequirements( static_cast<VkDevice>( m_device ),
8013 reinterpret_cast<const VkDeviceImageMemoryRequirements *>( pInfo ),
8014 pSparseMemoryRequirementCount,
8015 reinterpret_cast<VkSparseImageMemoryRequirements2 *>( pSparseMemoryRequirements ) );
8016 }
8017
8018 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8019 // wrapper function for command vkGetDeviceImageSparseMemoryRequirements, see
8020 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSparseMemoryRequirements.html
8021 template <
8022 typename SparseImageMemoryRequirements2Allocator,
8023 typename Dispatch,
8024 typename std::enable_if<std::is_same<typename SparseImageMemoryRequirements2Allocator::value_type, SparseImageMemoryRequirements2>::value, int>::type,
8025 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8026 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
8027 Device::getImageSparseMemoryRequirements( const DeviceImageMemoryRequirements & info, Dispatch const & d ) const
8028 {
8029 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8030 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
8031 VULKAN_HPP_ASSERT( d.vkGetDeviceImageSparseMemoryRequirements &&
8032 "Function <vkGetDeviceImageSparseMemoryRequirements> requires <VK_KHR_maintenance4> or <VK_VERSION_1_3>" );
8033 # endif
8034
8035 std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> sparseMemoryRequirements;
8036 uint32_t sparseMemoryRequirementCount;
8037 d.vkGetDeviceImageSparseMemoryRequirements(
8038 m_device, reinterpret_cast<const VkDeviceImageMemoryRequirements *>( &info ), &sparseMemoryRequirementCount, nullptr );
8039 sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
8040 d.vkGetDeviceImageSparseMemoryRequirements( m_device,
8041 reinterpret_cast<const VkDeviceImageMemoryRequirements *>( &info ),
8042 &sparseMemoryRequirementCount,
8043 reinterpret_cast<VkSparseImageMemoryRequirements2 *>( sparseMemoryRequirements.data() ) );
8044
8045 VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() );
8046 if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() )
8047 {
8048 sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
8049 }
8050 return sparseMemoryRequirements;
8051 }
8052
8053 // wrapper function for command vkGetDeviceImageSparseMemoryRequirements, see
8054 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSparseMemoryRequirements.html
8055 template <
8056 typename SparseImageMemoryRequirements2Allocator,
8057 typename Dispatch,
8058 typename std::enable_if<std::is_same<typename SparseImageMemoryRequirements2Allocator::value_type, SparseImageMemoryRequirements2>::value, int>::type,
8059 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8060 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
8061 Device::getImageSparseMemoryRequirements( const DeviceImageMemoryRequirements & info,
8062 SparseImageMemoryRequirements2Allocator & sparseImageMemoryRequirements2Allocator,
8063 Dispatch const & d ) const
8064 {
8065 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8066 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
8067 VULKAN_HPP_ASSERT( d.vkGetDeviceImageSparseMemoryRequirements &&
8068 "Function <vkGetDeviceImageSparseMemoryRequirements> requires <VK_KHR_maintenance4> or <VK_VERSION_1_3>" );
8069 # endif
8070
8071 std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> sparseMemoryRequirements( sparseImageMemoryRequirements2Allocator );
8072 uint32_t sparseMemoryRequirementCount;
8073 d.vkGetDeviceImageSparseMemoryRequirements(
8074 m_device, reinterpret_cast<const VkDeviceImageMemoryRequirements *>( &info ), &sparseMemoryRequirementCount, nullptr );
8075 sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
8076 d.vkGetDeviceImageSparseMemoryRequirements( m_device,
8077 reinterpret_cast<const VkDeviceImageMemoryRequirements *>( &info ),
8078 &sparseMemoryRequirementCount,
8079 reinterpret_cast<VkSparseImageMemoryRequirements2 *>( sparseMemoryRequirements.data() ) );
8080
8081 VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() );
8082 if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() )
8083 {
8084 sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
8085 }
8086 return sparseMemoryRequirements;
8087 }
8088 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8089
8090 // wrapper function for command vkCmdSetEvent2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetEvent2.html
8091 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8092 VULKAN_HPP_INLINE void CommandBuffer::setEvent2( Event event, const DependencyInfo * pDependencyInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
8093 {
8094 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8095 d.vkCmdSetEvent2(
8096 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkEvent>( event ), reinterpret_cast<const VkDependencyInfo *>( pDependencyInfo ) );
8097 }
8098
8099 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8100 // wrapper function for command vkCmdSetEvent2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetEvent2.html
8101 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8102 VULKAN_HPP_INLINE void CommandBuffer::setEvent2( Event event, const DependencyInfo & dependencyInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
8103 {
8104 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8105 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
8106 VULKAN_HPP_ASSERT( d.vkCmdSetEvent2 && "Function <vkCmdSetEvent2> requires <VK_KHR_synchronization2> or <VK_VERSION_1_3>" );
8107 # endif
8108
8109 d.vkCmdSetEvent2( m_commandBuffer, static_cast<VkEvent>( event ), reinterpret_cast<const VkDependencyInfo *>( &dependencyInfo ) );
8110 }
8111 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8112
8113 // wrapper function for command vkCmdResetEvent2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResetEvent2.html
8114 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8115 VULKAN_HPP_INLINE void CommandBuffer::resetEvent2( Event event, PipelineStageFlags2 stageMask, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
8116 {
8117 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8118 d.vkCmdResetEvent2( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkEvent>( event ), static_cast<VkPipelineStageFlags2>( stageMask ) );
8119 }
8120
8121 // wrapper function for command vkCmdWaitEvents2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWaitEvents2.html
8122 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8123 VULKAN_HPP_INLINE void CommandBuffer::waitEvents2( uint32_t eventCount,
8124 const Event * pEvents,
8125 const DependencyInfo * pDependencyInfos,
8126 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
8127 {
8128 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8129 d.vkCmdWaitEvents2( static_cast<VkCommandBuffer>( m_commandBuffer ),
8130 eventCount,
8131 reinterpret_cast<const VkEvent *>( pEvents ),
8132 reinterpret_cast<const VkDependencyInfo *>( pDependencyInfos ) );
8133 }
8134
8135 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8136 // wrapper function for command vkCmdWaitEvents2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWaitEvents2.html
8137 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8138 VULKAN_HPP_INLINE void CommandBuffer::waitEvents2( ArrayProxy<const Event> const & events,
8139 ArrayProxy<const DependencyInfo> const & dependencyInfos,
8140 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
8141 {
8142 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8143 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
8144 VULKAN_HPP_ASSERT( d.vkCmdWaitEvents2 && "Function <vkCmdWaitEvents2> requires <VK_KHR_synchronization2> or <VK_VERSION_1_3>" );
8145 # endif
8146 # ifdef VULKAN_HPP_NO_EXCEPTIONS
8147 VULKAN_HPP_ASSERT( events.size() == dependencyInfos.size() );
8148 # else
8149 if ( events.size() != dependencyInfos.size() )
8150 {
8151 throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::waitEvents2: events.size() != dependencyInfos.size()" );
8152 }
8153 # endif /*VULKAN_HPP_NO_EXCEPTIONS*/
8154
8155 d.vkCmdWaitEvents2( m_commandBuffer,
8156 events.size(),
8157 reinterpret_cast<const VkEvent *>( events.data() ),
8158 reinterpret_cast<const VkDependencyInfo *>( dependencyInfos.data() ) );
8159 }
8160 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8161
8162 // wrapper function for command vkCmdBlitImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBlitImage2.html
8163 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8164 VULKAN_HPP_INLINE void CommandBuffer::blitImage2( const BlitImageInfo2 * pBlitImageInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
8165 {
8166 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8167 d.vkCmdBlitImage2( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkBlitImageInfo2 *>( pBlitImageInfo ) );
8168 }
8169
8170 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8171 // wrapper function for command vkCmdBlitImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBlitImage2.html
8172 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8173 VULKAN_HPP_INLINE void CommandBuffer::blitImage2( const BlitImageInfo2 & blitImageInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
8174 {
8175 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8176 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
8177 VULKAN_HPP_ASSERT( d.vkCmdBlitImage2 && "Function <vkCmdBlitImage2> requires <VK_KHR_copy_commands2> or <VK_VERSION_1_3>" );
8178 # endif
8179
8180 d.vkCmdBlitImage2( m_commandBuffer, reinterpret_cast<const VkBlitImageInfo2 *>( &blitImageInfo ) );
8181 }
8182 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8183
8184 // wrapper function for command vkCmdResolveImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResolveImage2.html
8185 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8186 VULKAN_HPP_INLINE void CommandBuffer::resolveImage2( const ResolveImageInfo2 * pResolveImageInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
8187 {
8188 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8189 d.vkCmdResolveImage2( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkResolveImageInfo2 *>( pResolveImageInfo ) );
8190 }
8191
8192 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8193 // wrapper function for command vkCmdResolveImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResolveImage2.html
8194 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8195 VULKAN_HPP_INLINE void CommandBuffer::resolveImage2( const ResolveImageInfo2 & resolveImageInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
8196 {
8197 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8198 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
8199 VULKAN_HPP_ASSERT( d.vkCmdResolveImage2 && "Function <vkCmdResolveImage2> requires <VK_KHR_copy_commands2> or <VK_VERSION_1_3>" );
8200 # endif
8201
8202 d.vkCmdResolveImage2( m_commandBuffer, reinterpret_cast<const VkResolveImageInfo2 *>( &resolveImageInfo ) );
8203 }
8204 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8205
8206 // wrapper function for command vkCmdBeginRendering, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRendering.html
8207 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8208 VULKAN_HPP_INLINE void CommandBuffer::beginRendering( const RenderingInfo * pRenderingInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
8209 {
8210 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8211 d.vkCmdBeginRendering( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkRenderingInfo *>( pRenderingInfo ) );
8212 }
8213
8214 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8215 // wrapper function for command vkCmdBeginRendering, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRendering.html
8216 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8217 VULKAN_HPP_INLINE void CommandBuffer::beginRendering( const RenderingInfo & renderingInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
8218 {
8219 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8220 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
8221 VULKAN_HPP_ASSERT( d.vkCmdBeginRendering && "Function <vkCmdBeginRendering> requires <VK_KHR_dynamic_rendering> or <VK_VERSION_1_3>" );
8222 # endif
8223
8224 d.vkCmdBeginRendering( m_commandBuffer, reinterpret_cast<const VkRenderingInfo *>( &renderingInfo ) );
8225 }
8226 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8227
8228 // wrapper function for command vkCmdEndRendering, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering.html
8229 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8230 VULKAN_HPP_INLINE void CommandBuffer::endRendering( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
8231 {
8232 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8233 d.vkCmdEndRendering( static_cast<VkCommandBuffer>( m_commandBuffer ) );
8234 }
8235
8236 // wrapper function for command vkCmdSetCullMode, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCullMode.html
8237 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8238 VULKAN_HPP_INLINE void CommandBuffer::setCullMode( CullModeFlags cullMode, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
8239 {
8240 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8241 d.vkCmdSetCullMode( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkCullModeFlags>( cullMode ) );
8242 }
8243
8244 // wrapper function for command vkCmdSetFrontFace, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFrontFace.html
8245 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8246 VULKAN_HPP_INLINE void CommandBuffer::setFrontFace( FrontFace frontFace, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
8247 {
8248 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8249 d.vkCmdSetFrontFace( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkFrontFace>( frontFace ) );
8250 }
8251
8252 // wrapper function for command vkCmdSetPrimitiveTopology, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPrimitiveTopology.html
8253 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8254 VULKAN_HPP_INLINE void CommandBuffer::setPrimitiveTopology( PrimitiveTopology primitiveTopology, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
8255 {
8256 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8257 d.vkCmdSetPrimitiveTopology( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkPrimitiveTopology>( primitiveTopology ) );
8258 }
8259
8260 // wrapper function for command vkCmdSetViewportWithCount, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWithCount.html
8261 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8262 VULKAN_HPP_INLINE void
8263 CommandBuffer::setViewportWithCount( uint32_t viewportCount, const Viewport * pViewports, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
8264 {
8265 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8266 d.vkCmdSetViewportWithCount( static_cast<VkCommandBuffer>( m_commandBuffer ), viewportCount, reinterpret_cast<const VkViewport *>( pViewports ) );
8267 }
8268
8269 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8270 // wrapper function for command vkCmdSetViewportWithCount, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWithCount.html
8271 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8272 VULKAN_HPP_INLINE void CommandBuffer::setViewportWithCount( ArrayProxy<const Viewport> const & viewports, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
8273 {
8274 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8275 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
8276 VULKAN_HPP_ASSERT( d.vkCmdSetViewportWithCount &&
8277 "Function <vkCmdSetViewportWithCount> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" );
8278 # endif
8279
8280 d.vkCmdSetViewportWithCount( m_commandBuffer, viewports.size(), reinterpret_cast<const VkViewport *>( viewports.data() ) );
8281 }
8282 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8283
8284 // wrapper function for command vkCmdSetScissorWithCount, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetScissorWithCount.html
8285 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8286 VULKAN_HPP_INLINE void CommandBuffer::setScissorWithCount( uint32_t scissorCount, const Rect2D * pScissors, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
8287 {
8288 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8289 d.vkCmdSetScissorWithCount( static_cast<VkCommandBuffer>( m_commandBuffer ), scissorCount, reinterpret_cast<const VkRect2D *>( pScissors ) );
8290 }
8291
8292 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8293 // wrapper function for command vkCmdSetScissorWithCount, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetScissorWithCount.html
8294 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8295 VULKAN_HPP_INLINE void CommandBuffer::setScissorWithCount( ArrayProxy<const Rect2D> const & scissors, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
8296 {
8297 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8298 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
8299 VULKAN_HPP_ASSERT( d.vkCmdSetScissorWithCount &&
8300 "Function <vkCmdSetScissorWithCount> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" );
8301 # endif
8302
8303 d.vkCmdSetScissorWithCount( m_commandBuffer, scissors.size(), reinterpret_cast<const VkRect2D *>( scissors.data() ) );
8304 }
8305 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8306
8307 // wrapper function for command vkCmdBindVertexBuffers2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers2.html
8308 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8309 VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers2( uint32_t firstBinding,
8310 uint32_t bindingCount,
8311 const Buffer * pBuffers,
8312 const DeviceSize * pOffsets,
8313 const DeviceSize * pSizes,
8314 const DeviceSize * pStrides,
8315 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
8316 {
8317 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8318 d.vkCmdBindVertexBuffers2( static_cast<VkCommandBuffer>( m_commandBuffer ),
8319 firstBinding,
8320 bindingCount,
8321 reinterpret_cast<const VkBuffer *>( pBuffers ),
8322 reinterpret_cast<const VkDeviceSize *>( pOffsets ),
8323 reinterpret_cast<const VkDeviceSize *>( pSizes ),
8324 reinterpret_cast<const VkDeviceSize *>( pStrides ) );
8325 }
8326
8327 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8328 // wrapper function for command vkCmdBindVertexBuffers2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers2.html
8329 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8330 VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers2( uint32_t firstBinding,
8331 ArrayProxy<const Buffer> const & buffers,
8332 ArrayProxy<const DeviceSize> const & offsets,
8333 ArrayProxy<const DeviceSize> const & sizes,
8334 ArrayProxy<const DeviceSize> const & strides,
8335 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
8336 {
8337 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8338 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
8339 VULKAN_HPP_ASSERT( d.vkCmdBindVertexBuffers2 &&
8340 "Function <vkCmdBindVertexBuffers2> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" );
8341 # endif
8342 # ifdef VULKAN_HPP_NO_EXCEPTIONS
8343 VULKAN_HPP_ASSERT( buffers.size() == offsets.size() );
8344 VULKAN_HPP_ASSERT( sizes.empty() || buffers.size() == sizes.size() );
8345 VULKAN_HPP_ASSERT( strides.empty() || buffers.size() == strides.size() );
8346 # else
8347 if ( buffers.size() != offsets.size() )
8348 {
8349 throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers2: buffers.size() != offsets.size()" );
8350 }
8351 if ( !sizes.empty() && buffers.size() != sizes.size() )
8352 {
8353 throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers2: buffers.size() != sizes.size()" );
8354 }
8355 if ( !strides.empty() && buffers.size() != strides.size() )
8356 {
8357 throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers2: buffers.size() != strides.size()" );
8358 }
8359 # endif /*VULKAN_HPP_NO_EXCEPTIONS*/
8360
8361 d.vkCmdBindVertexBuffers2( m_commandBuffer,
8362 firstBinding,
8363 buffers.size(),
8364 reinterpret_cast<const VkBuffer *>( buffers.data() ),
8365 reinterpret_cast<const VkDeviceSize *>( offsets.data() ),
8366 reinterpret_cast<const VkDeviceSize *>( sizes.data() ),
8367 reinterpret_cast<const VkDeviceSize *>( strides.data() ) );
8368 }
8369 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8370
8371 // wrapper function for command vkCmdSetDepthTestEnable, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthTestEnable.html
8372 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8373 VULKAN_HPP_INLINE void CommandBuffer::setDepthTestEnable( Bool32 depthTestEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
8374 {
8375 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8376 d.vkCmdSetDepthTestEnable( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( depthTestEnable ) );
8377 }
8378
8379 // wrapper function for command vkCmdSetDepthWriteEnable, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthWriteEnable.html
8380 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8381 VULKAN_HPP_INLINE void CommandBuffer::setDepthWriteEnable( Bool32 depthWriteEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
8382 {
8383 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8384 d.vkCmdSetDepthWriteEnable( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( depthWriteEnable ) );
8385 }
8386
8387 // wrapper function for command vkCmdSetDepthCompareOp, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthCompareOp.html
8388 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8389 VULKAN_HPP_INLINE void CommandBuffer::setDepthCompareOp( CompareOp depthCompareOp, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
8390 {
8391 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8392 d.vkCmdSetDepthCompareOp( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkCompareOp>( depthCompareOp ) );
8393 }
8394
8395 // wrapper function for command vkCmdSetDepthBoundsTestEnable, see
8396 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBoundsTestEnable.html
8397 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8398 VULKAN_HPP_INLINE void CommandBuffer::setDepthBoundsTestEnable( Bool32 depthBoundsTestEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
8399 {
8400 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8401 d.vkCmdSetDepthBoundsTestEnable( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( depthBoundsTestEnable ) );
8402 }
8403
8404 // wrapper function for command vkCmdSetStencilTestEnable, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilTestEnable.html
8405 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8406 VULKAN_HPP_INLINE void CommandBuffer::setStencilTestEnable( Bool32 stencilTestEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
8407 {
8408 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8409 d.vkCmdSetStencilTestEnable( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( stencilTestEnable ) );
8410 }
8411
8412 // wrapper function for command vkCmdSetStencilOp, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilOp.html
8413 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8414 VULKAN_HPP_INLINE void CommandBuffer::setStencilOp(
8415 StencilFaceFlags faceMask, StencilOp failOp, StencilOp passOp, StencilOp depthFailOp, CompareOp compareOp, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
8416 {
8417 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8418 d.vkCmdSetStencilOp( static_cast<VkCommandBuffer>( m_commandBuffer ),
8419 static_cast<VkStencilFaceFlags>( faceMask ),
8420 static_cast<VkStencilOp>( failOp ),
8421 static_cast<VkStencilOp>( passOp ),
8422 static_cast<VkStencilOp>( depthFailOp ),
8423 static_cast<VkCompareOp>( compareOp ) );
8424 }
8425
8426 // wrapper function for command vkCmdSetRasterizerDiscardEnable, see
8427 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRasterizerDiscardEnable.html
8428 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8429 VULKAN_HPP_INLINE void CommandBuffer::setRasterizerDiscardEnable( Bool32 rasterizerDiscardEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
8430 {
8431 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8432 d.vkCmdSetRasterizerDiscardEnable( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( rasterizerDiscardEnable ) );
8433 }
8434
8435 // wrapper function for command vkCmdSetDepthBiasEnable, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBiasEnable.html
8436 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8437 VULKAN_HPP_INLINE void CommandBuffer::setDepthBiasEnable( Bool32 depthBiasEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
8438 {
8439 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8440 d.vkCmdSetDepthBiasEnable( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( depthBiasEnable ) );
8441 }
8442
8443 // wrapper function for command vkCmdSetPrimitiveRestartEnable, see
8444 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPrimitiveRestartEnable.html
8445 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8446 VULKAN_HPP_INLINE void CommandBuffer::setPrimitiveRestartEnable( Bool32 primitiveRestartEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
8447 {
8448 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8449 d.vkCmdSetPrimitiveRestartEnable( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( primitiveRestartEnable ) );
8450 }
8451
8452 //=== VK_VERSION_1_4 ===
8453
8454 // wrapper function for command vkMapMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMapMemory2.html
8455 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8456 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::mapMemory2( const MemoryMapInfo * pMemoryMapInfo,
8457 void ** ppData,
8458 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
8459 {
8460 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8461 return static_cast<Result>( d.vkMapMemory2( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkMemoryMapInfo *>( pMemoryMapInfo ), ppData ) );
8462 }
8463
8464 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8465 // wrapper function for command vkMapMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMapMemory2.html
8466 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8467 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<void *>::type Device::mapMemory2( const MemoryMapInfo & memoryMapInfo,
8468 Dispatch const & d ) const
8469 {
8470 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8471 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
8472 VULKAN_HPP_ASSERT( d.vkMapMemory2 && "Function <vkMapMemory2> requires <VK_KHR_map_memory2> or <VK_VERSION_1_4>" );
8473 # endif
8474
8475 void * pData;
8476 Result result = static_cast<Result>( d.vkMapMemory2( m_device, reinterpret_cast<const VkMemoryMapInfo *>( &memoryMapInfo ), &pData ) );
8477 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::mapMemory2" );
8478
8479 return detail::createResultValueType( result, std::move( pData ) );
8480 }
8481 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8482
8483 // wrapper function for command vkUnmapMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnmapMemory2.html
8484 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8485 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::unmapMemory2( const MemoryUnmapInfo * pMemoryUnmapInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
8486 {
8487 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8488 return static_cast<Result>( d.vkUnmapMemory2( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkMemoryUnmapInfo *>( pMemoryUnmapInfo ) ) );
8489 }
8490
8491 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8492 // wrapper function for command vkUnmapMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnmapMemory2.html
8493 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8494 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::unmapMemory2( const MemoryUnmapInfo & memoryUnmapInfo,
8495 Dispatch const & d ) const
8496 {
8497 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8498 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
8499 VULKAN_HPP_ASSERT( d.vkUnmapMemory2 && "Function <vkUnmapMemory2> requires <VK_KHR_map_memory2> or <VK_VERSION_1_4>" );
8500 # endif
8501
8502 Result result = static_cast<Result>( d.vkUnmapMemory2( m_device, reinterpret_cast<const VkMemoryUnmapInfo *>( &memoryUnmapInfo ) ) );
8503 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::unmapMemory2" );
8504
8505 return detail::createResultValueType( result );
8506 }
8507 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8508
8509 // wrapper function for command vkGetDeviceImageSubresourceLayout, see
8510 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSubresourceLayout.html
8511 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8512 VULKAN_HPP_INLINE void
8513 Device::getImageSubresourceLayout( const DeviceImageSubresourceInfo * pInfo, SubresourceLayout2 * pLayout, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
8514 {
8515 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8516 d.vkGetDeviceImageSubresourceLayout(
8517 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkDeviceImageSubresourceInfo *>( pInfo ), reinterpret_cast<VkSubresourceLayout2 *>( pLayout ) );
8518 }
8519
8520 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8521 // wrapper function for command vkGetDeviceImageSubresourceLayout, see
8522 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSubresourceLayout.html
8523 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8524 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE SubresourceLayout2 Device::getImageSubresourceLayout( const DeviceImageSubresourceInfo & info,
8525 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
8526 {
8527 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8528 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
8529 VULKAN_HPP_ASSERT( d.vkGetDeviceImageSubresourceLayout &&
8530 "Function <vkGetDeviceImageSubresourceLayout> requires <VK_KHR_maintenance5> or <VK_VERSION_1_4>" );
8531 # endif
8532
8533 SubresourceLayout2 layout;
8534 d.vkGetDeviceImageSubresourceLayout(
8535 m_device, reinterpret_cast<const VkDeviceImageSubresourceInfo *>( &info ), reinterpret_cast<VkSubresourceLayout2 *>( &layout ) );
8536
8537 return layout;
8538 }
8539
8540 // wrapper function for command vkGetDeviceImageSubresourceLayout, see
8541 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSubresourceLayout.html
8542 template <typename X, typename Y, typename... Z, typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8543 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getImageSubresourceLayout( const DeviceImageSubresourceInfo & info,
8544 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
8545 {
8546 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8547 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
8548 VULKAN_HPP_ASSERT( d.vkGetDeviceImageSubresourceLayout &&
8549 "Function <vkGetDeviceImageSubresourceLayout> requires <VK_KHR_maintenance5> or <VK_VERSION_1_4>" );
8550 # endif
8551
8552 StructureChain<X, Y, Z...> structureChain;
8553 SubresourceLayout2 & layout = structureChain.template get<SubresourceLayout2>();
8554 d.vkGetDeviceImageSubresourceLayout(
8555 m_device, reinterpret_cast<const VkDeviceImageSubresourceInfo *>( &info ), reinterpret_cast<VkSubresourceLayout2 *>( &layout ) );
8556
8557 return structureChain;
8558 }
8559 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8560
8561 // wrapper function for command vkGetImageSubresourceLayout2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2.html
8562 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8563 VULKAN_HPP_INLINE void Device::getImageSubresourceLayout2( Image image,
8564 const ImageSubresource2 * pSubresource,
8565 SubresourceLayout2 * pLayout,
8566 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
8567 {
8568 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8569 d.vkGetImageSubresourceLayout2( static_cast<VkDevice>( m_device ),
8570 static_cast<VkImage>( image ),
8571 reinterpret_cast<const VkImageSubresource2 *>( pSubresource ),
8572 reinterpret_cast<VkSubresourceLayout2 *>( pLayout ) );
8573 }
8574
8575 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8576 // wrapper function for command vkGetImageSubresourceLayout2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2.html
8577 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8578 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE SubresourceLayout2 Device::getImageSubresourceLayout2( Image image,
8579 const ImageSubresource2 & subresource,
8580 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
8581 {
8582 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8583 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
8584 VULKAN_HPP_ASSERT(
8585 d.vkGetImageSubresourceLayout2 &&
8586 "Function <vkGetImageSubresourceLayout2> requires <VK_EXT_host_image_copy> or <VK_EXT_image_compression_control> or <VK_KHR_maintenance5> or <VK_VERSION_1_4>" );
8587 # endif
8588
8589 SubresourceLayout2 layout;
8590 d.vkGetImageSubresourceLayout2( m_device,
8591 static_cast<VkImage>( image ),
8592 reinterpret_cast<const VkImageSubresource2 *>( &subresource ),
8593 reinterpret_cast<VkSubresourceLayout2 *>( &layout ) );
8594
8595 return layout;
8596 }
8597
8598 // wrapper function for command vkGetImageSubresourceLayout2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2.html
8599 template <typename X, typename Y, typename... Z, typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8600 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...>
8601 Device::getImageSubresourceLayout2( Image image, const ImageSubresource2 & subresource, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
8602 {
8603 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8604 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
8605 VULKAN_HPP_ASSERT(
8606 d.vkGetImageSubresourceLayout2 &&
8607 "Function <vkGetImageSubresourceLayout2> requires <VK_EXT_host_image_copy> or <VK_EXT_image_compression_control> or <VK_KHR_maintenance5> or <VK_VERSION_1_4>" );
8608 # endif
8609
8610 StructureChain<X, Y, Z...> structureChain;
8611 SubresourceLayout2 & layout = structureChain.template get<SubresourceLayout2>();
8612 d.vkGetImageSubresourceLayout2( m_device,
8613 static_cast<VkImage>( image ),
8614 reinterpret_cast<const VkImageSubresource2 *>( &subresource ),
8615 reinterpret_cast<VkSubresourceLayout2 *>( &layout ) );
8616
8617 return structureChain;
8618 }
8619 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8620
8621 // wrapper function for command vkCopyMemoryToImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToImage.html
8622 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8623 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyMemoryToImage( const CopyMemoryToImageInfo * pCopyMemoryToImageInfo,
8624 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
8625 {
8626 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8627 return static_cast<Result>(
8628 d.vkCopyMemoryToImage( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkCopyMemoryToImageInfo *>( pCopyMemoryToImageInfo ) ) );
8629 }
8630
8631 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8632 // wrapper function for command vkCopyMemoryToImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToImage.html
8633 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8634 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
8635 Device::copyMemoryToImage( const CopyMemoryToImageInfo & copyMemoryToImageInfo, Dispatch const & d ) const
8636 {
8637 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8638 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
8639 VULKAN_HPP_ASSERT( d.vkCopyMemoryToImage && "Function <vkCopyMemoryToImage> requires <VK_EXT_host_image_copy> or <VK_VERSION_1_4>" );
8640 # endif
8641
8642 Result result = static_cast<Result>( d.vkCopyMemoryToImage( m_device, reinterpret_cast<const VkCopyMemoryToImageInfo *>( &copyMemoryToImageInfo ) ) );
8643 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::copyMemoryToImage" );
8644
8645 return detail::createResultValueType( result );
8646 }
8647 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8648
8649 // wrapper function for command vkCopyImageToMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToMemory.html
8650 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8651 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyImageToMemory( const CopyImageToMemoryInfo * pCopyImageToMemoryInfo,
8652 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
8653 {
8654 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8655 return static_cast<Result>(
8656 d.vkCopyImageToMemory( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkCopyImageToMemoryInfo *>( pCopyImageToMemoryInfo ) ) );
8657 }
8658
8659 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8660 // wrapper function for command vkCopyImageToMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToMemory.html
8661 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8662 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
8663 Device::copyImageToMemory( const CopyImageToMemoryInfo & copyImageToMemoryInfo, Dispatch const & d ) const
8664 {
8665 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8666 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
8667 VULKAN_HPP_ASSERT( d.vkCopyImageToMemory && "Function <vkCopyImageToMemory> requires <VK_EXT_host_image_copy> or <VK_VERSION_1_4>" );
8668 # endif
8669
8670 Result result = static_cast<Result>( d.vkCopyImageToMemory( m_device, reinterpret_cast<const VkCopyImageToMemoryInfo *>( &copyImageToMemoryInfo ) ) );
8671 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::copyImageToMemory" );
8672
8673 return detail::createResultValueType( result );
8674 }
8675 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8676
8677 // wrapper function for command vkCopyImageToImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToImage.html
8678 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8679 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyImageToImage( const CopyImageToImageInfo * pCopyImageToImageInfo,
8680 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
8681 {
8682 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8683 return static_cast<Result>(
8684 d.vkCopyImageToImage( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkCopyImageToImageInfo *>( pCopyImageToImageInfo ) ) );
8685 }
8686
8687 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8688 // wrapper function for command vkCopyImageToImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToImage.html
8689 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8690 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
8691 Device::copyImageToImage( const CopyImageToImageInfo & copyImageToImageInfo, Dispatch const & d ) const
8692 {
8693 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8694 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
8695 VULKAN_HPP_ASSERT( d.vkCopyImageToImage && "Function <vkCopyImageToImage> requires <VK_EXT_host_image_copy> or <VK_VERSION_1_4>" );
8696 # endif
8697
8698 Result result = static_cast<Result>( d.vkCopyImageToImage( m_device, reinterpret_cast<const VkCopyImageToImageInfo *>( &copyImageToImageInfo ) ) );
8699 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::copyImageToImage" );
8700
8701 return detail::createResultValueType( result );
8702 }
8703 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8704
8705 // wrapper function for command vkTransitionImageLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkTransitionImageLayout.html
8706 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8707 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::transitionImageLayout( uint32_t transitionCount,
8708 const HostImageLayoutTransitionInfo * pTransitions,
8709 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
8710 {
8711 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8712 return static_cast<Result>( d.vkTransitionImageLayout(
8713 static_cast<VkDevice>( m_device ), transitionCount, reinterpret_cast<const VkHostImageLayoutTransitionInfo *>( pTransitions ) ) );
8714 }
8715
8716 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8717 // wrapper function for command vkTransitionImageLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkTransitionImageLayout.html
8718 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8719 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
8720 Device::transitionImageLayout( ArrayProxy<const HostImageLayoutTransitionInfo> const & transitions, Dispatch const & d ) const
8721 {
8722 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8723 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
8724 VULKAN_HPP_ASSERT( d.vkTransitionImageLayout && "Function <vkTransitionImageLayout> requires <VK_EXT_host_image_copy> or <VK_VERSION_1_4>" );
8725 # endif
8726
8727 Result result = static_cast<Result>(
8728 d.vkTransitionImageLayout( m_device, transitions.size(), reinterpret_cast<const VkHostImageLayoutTransitionInfo *>( transitions.data() ) ) );
8729 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::transitionImageLayout" );
8730
8731 return detail::createResultValueType( result );
8732 }
8733 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8734
8735 // wrapper function for command vkCmdPushDescriptorSet, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSet.html
8736 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8737 VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSet( PipelineBindPoint pipelineBindPoint,
8738 PipelineLayout layout,
8739 uint32_t set,
8740 uint32_t descriptorWriteCount,
8741 const WriteDescriptorSet * pDescriptorWrites,
8742 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
8743 {
8744 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8745 d.vkCmdPushDescriptorSet( static_cast<VkCommandBuffer>( m_commandBuffer ),
8746 static_cast<VkPipelineBindPoint>( pipelineBindPoint ),
8747 static_cast<VkPipelineLayout>( layout ),
8748 set,
8749 descriptorWriteCount,
8750 reinterpret_cast<const VkWriteDescriptorSet *>( pDescriptorWrites ) );
8751 }
8752
8753 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8754 // wrapper function for command vkCmdPushDescriptorSet, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSet.html
8755 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8756 VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSet( PipelineBindPoint pipelineBindPoint,
8757 PipelineLayout layout,
8758 uint32_t set,
8759 ArrayProxy<const WriteDescriptorSet> const & descriptorWrites,
8760 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
8761 {
8762 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8763 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
8764 VULKAN_HPP_ASSERT( d.vkCmdPushDescriptorSet && "Function <vkCmdPushDescriptorSet> requires <VK_KHR_push_descriptor> or <VK_VERSION_1_4>" );
8765 # endif
8766
8767 d.vkCmdPushDescriptorSet( m_commandBuffer,
8768 static_cast<VkPipelineBindPoint>( pipelineBindPoint ),
8769 static_cast<VkPipelineLayout>( layout ),
8770 set,
8771 descriptorWrites.size(),
8772 reinterpret_cast<const VkWriteDescriptorSet *>( descriptorWrites.data() ) );
8773 }
8774 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8775
8776 // wrapper function for command vkCmdPushDescriptorSetWithTemplate, see
8777 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplate.html
8778 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8779 VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplate(
8780 DescriptorUpdateTemplate descriptorUpdateTemplate, PipelineLayout layout, uint32_t set, const void * pData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
8781 {
8782 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8783 d.vkCmdPushDescriptorSetWithTemplate( static_cast<VkCommandBuffer>( m_commandBuffer ),
8784 static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
8785 static_cast<VkPipelineLayout>( layout ),
8786 set,
8787 pData );
8788 }
8789
8790 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8791 // wrapper function for command vkCmdPushDescriptorSetWithTemplate, see
8792 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplate.html
8793 template <typename DataType, typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8794 VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplate( DescriptorUpdateTemplate descriptorUpdateTemplate,
8795 PipelineLayout layout,
8796 uint32_t set,
8797 DataType const & data,
8798 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
8799 {
8800 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8801 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
8802 VULKAN_HPP_ASSERT(
8803 d.vkCmdPushDescriptorSetWithTemplate &&
8804 "Function <vkCmdPushDescriptorSetWithTemplate> requires <VK_KHR_descriptor_update_template> or <VK_KHR_push_descriptor> or <VK_VERSION_1_4>" );
8805 # endif
8806
8807 d.vkCmdPushDescriptorSetWithTemplate( m_commandBuffer,
8808 static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
8809 static_cast<VkPipelineLayout>( layout ),
8810 set,
8811 reinterpret_cast<const void *>( &data ) );
8812 }
8813 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8814
8815 // wrapper function for command vkCmdBindDescriptorSets2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorSets2.html
8816 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8817 VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorSets2( const BindDescriptorSetsInfo * pBindDescriptorSetsInfo,
8818 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
8819 {
8820 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8821 d.vkCmdBindDescriptorSets2( static_cast<VkCommandBuffer>( m_commandBuffer ),
8822 reinterpret_cast<const VkBindDescriptorSetsInfo *>( pBindDescriptorSetsInfo ) );
8823 }
8824
8825 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8826 // wrapper function for command vkCmdBindDescriptorSets2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorSets2.html
8827 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8828 VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorSets2( const BindDescriptorSetsInfo & bindDescriptorSetsInfo,
8829 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
8830 {
8831 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8832 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
8833 VULKAN_HPP_ASSERT( d.vkCmdBindDescriptorSets2 && "Function <vkCmdBindDescriptorSets2> requires <VK_KHR_maintenance6> or <VK_VERSION_1_4>" );
8834 # endif
8835
8836 d.vkCmdBindDescriptorSets2( m_commandBuffer, reinterpret_cast<const VkBindDescriptorSetsInfo *>( &bindDescriptorSetsInfo ) );
8837 }
8838 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8839
8840 // wrapper function for command vkCmdPushConstants2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushConstants2.html
8841 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8842 VULKAN_HPP_INLINE void CommandBuffer::pushConstants2( const PushConstantsInfo * pPushConstantsInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
8843 {
8844 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8845 d.vkCmdPushConstants2( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkPushConstantsInfo *>( pPushConstantsInfo ) );
8846 }
8847
8848 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8849 // wrapper function for command vkCmdPushConstants2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushConstants2.html
8850 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8851 VULKAN_HPP_INLINE void CommandBuffer::pushConstants2( const PushConstantsInfo & pushConstantsInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
8852 {
8853 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8854 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
8855 VULKAN_HPP_ASSERT( d.vkCmdPushConstants2 && "Function <vkCmdPushConstants2> requires <VK_KHR_maintenance6> or <VK_VERSION_1_4>" );
8856 # endif
8857
8858 d.vkCmdPushConstants2( m_commandBuffer, reinterpret_cast<const VkPushConstantsInfo *>( &pushConstantsInfo ) );
8859 }
8860 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8861
8862 // wrapper function for command vkCmdPushDescriptorSet2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSet2.html
8863 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8864 VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSet2( const PushDescriptorSetInfo * pPushDescriptorSetInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
8865 {
8866 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8867 d.vkCmdPushDescriptorSet2( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkPushDescriptorSetInfo *>( pPushDescriptorSetInfo ) );
8868 }
8869
8870 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8871 // wrapper function for command vkCmdPushDescriptorSet2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSet2.html
8872 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8873 VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSet2( const PushDescriptorSetInfo & pushDescriptorSetInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
8874 {
8875 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8876 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
8877 VULKAN_HPP_ASSERT( d.vkCmdPushDescriptorSet2 && "Function <vkCmdPushDescriptorSet2> requires <VK_KHR_maintenance6> or <VK_VERSION_1_4>" );
8878 # endif
8879
8880 d.vkCmdPushDescriptorSet2( m_commandBuffer, reinterpret_cast<const VkPushDescriptorSetInfo *>( &pushDescriptorSetInfo ) );
8881 }
8882 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8883
8884 // wrapper function for command vkCmdPushDescriptorSetWithTemplate2, see
8885 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplate2.html
8886 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8887 VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplate2( const PushDescriptorSetWithTemplateInfo * pPushDescriptorSetWithTemplateInfo,
8888 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
8889 {
8890 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8891 d.vkCmdPushDescriptorSetWithTemplate2( static_cast<VkCommandBuffer>( m_commandBuffer ),
8892 reinterpret_cast<const VkPushDescriptorSetWithTemplateInfo *>( pPushDescriptorSetWithTemplateInfo ) );
8893 }
8894
8895 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8896 // wrapper function for command vkCmdPushDescriptorSetWithTemplate2, see
8897 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplate2.html
8898 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8899 VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplate2( const PushDescriptorSetWithTemplateInfo & pushDescriptorSetWithTemplateInfo,
8900 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
8901 {
8902 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8903 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
8904 VULKAN_HPP_ASSERT( d.vkCmdPushDescriptorSetWithTemplate2 &&
8905 "Function <vkCmdPushDescriptorSetWithTemplate2> requires <VK_KHR_maintenance6> or <VK_VERSION_1_4>" );
8906 # endif
8907
8908 d.vkCmdPushDescriptorSetWithTemplate2( m_commandBuffer,
8909 reinterpret_cast<const VkPushDescriptorSetWithTemplateInfo *>( &pushDescriptorSetWithTemplateInfo ) );
8910 }
8911 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8912
8913 // wrapper function for command vkCmdSetLineStipple, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineStipple.html
8914 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8915 VULKAN_HPP_INLINE void CommandBuffer::setLineStipple( uint32_t lineStippleFactor, uint16_t lineStipplePattern, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
8916 {
8917 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8918 d.vkCmdSetLineStipple( static_cast<VkCommandBuffer>( m_commandBuffer ), lineStippleFactor, lineStipplePattern );
8919 }
8920
8921 // wrapper function for command vkCmdBindIndexBuffer2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindIndexBuffer2.html
8922 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8923 VULKAN_HPP_INLINE void
8924 CommandBuffer::bindIndexBuffer2( Buffer buffer, DeviceSize offset, DeviceSize size, IndexType indexType, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
8925 {
8926 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8927 d.vkCmdBindIndexBuffer2( static_cast<VkCommandBuffer>( m_commandBuffer ),
8928 static_cast<VkBuffer>( buffer ),
8929 static_cast<VkDeviceSize>( offset ),
8930 static_cast<VkDeviceSize>( size ),
8931 static_cast<VkIndexType>( indexType ) );
8932 }
8933
8934 // wrapper function for command vkGetRenderingAreaGranularity, see
8935 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRenderingAreaGranularity.html
8936 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8937 VULKAN_HPP_INLINE void
8938 Device::getRenderingAreaGranularity( const RenderingAreaInfo * pRenderingAreaInfo, Extent2D * pGranularity, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
8939 {
8940 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8941 d.vkGetRenderingAreaGranularity(
8942 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkRenderingAreaInfo *>( pRenderingAreaInfo ), reinterpret_cast<VkExtent2D *>( pGranularity ) );
8943 }
8944
8945 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8946 // wrapper function for command vkGetRenderingAreaGranularity, see
8947 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRenderingAreaGranularity.html
8948 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8949 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Extent2D Device::getRenderingAreaGranularity( const RenderingAreaInfo & renderingAreaInfo,
8950 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
8951 {
8952 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8953 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
8954 VULKAN_HPP_ASSERT( d.vkGetRenderingAreaGranularity && "Function <vkGetRenderingAreaGranularity> requires <VK_KHR_maintenance5> or <VK_VERSION_1_4>" );
8955 # endif
8956
8957 Extent2D granularity;
8958 d.vkGetRenderingAreaGranularity(
8959 m_device, reinterpret_cast<const VkRenderingAreaInfo *>( &renderingAreaInfo ), reinterpret_cast<VkExtent2D *>( &granularity ) );
8960
8961 return granularity;
8962 }
8963 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8964
8965 // wrapper function for command vkCmdSetRenderingAttachmentLocations, see
8966 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingAttachmentLocations.html
8967 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8968 VULKAN_HPP_INLINE void CommandBuffer::setRenderingAttachmentLocations( const RenderingAttachmentLocationInfo * pLocationInfo,
8969 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
8970 {
8971 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8972 d.vkCmdSetRenderingAttachmentLocations( static_cast<VkCommandBuffer>( m_commandBuffer ),
8973 reinterpret_cast<const VkRenderingAttachmentLocationInfo *>( pLocationInfo ) );
8974 }
8975
8976 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8977 // wrapper function for command vkCmdSetRenderingAttachmentLocations, see
8978 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingAttachmentLocations.html
8979 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8980 VULKAN_HPP_INLINE void CommandBuffer::setRenderingAttachmentLocations( const RenderingAttachmentLocationInfo & locationInfo,
8981 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
8982 {
8983 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
8984 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
8985 VULKAN_HPP_ASSERT( d.vkCmdSetRenderingAttachmentLocations &&
8986 "Function <vkCmdSetRenderingAttachmentLocations> requires <VK_KHR_dynamic_rendering_local_read> or <VK_VERSION_1_4>" );
8987 # endif
8988
8989 d.vkCmdSetRenderingAttachmentLocations( m_commandBuffer, reinterpret_cast<const VkRenderingAttachmentLocationInfo *>( &locationInfo ) );
8990 }
8991 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8992
8993 // wrapper function for command vkCmdSetRenderingInputAttachmentIndices, see
8994 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingInputAttachmentIndices.html
8995 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
8996 VULKAN_HPP_INLINE void CommandBuffer::setRenderingInputAttachmentIndices( const RenderingInputAttachmentIndexInfo * pInputAttachmentIndexInfo,
8997 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
8998 {
8999 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
9000 d.vkCmdSetRenderingInputAttachmentIndices( static_cast<VkCommandBuffer>( m_commandBuffer ),
9001 reinterpret_cast<const VkRenderingInputAttachmentIndexInfo *>( pInputAttachmentIndexInfo ) );
9002 }
9003
9004 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9005 // wrapper function for command vkCmdSetRenderingInputAttachmentIndices, see
9006 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingInputAttachmentIndices.html
9007 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
9008 VULKAN_HPP_INLINE void CommandBuffer::setRenderingInputAttachmentIndices( const RenderingInputAttachmentIndexInfo & inputAttachmentIndexInfo,
9009 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
9010 {
9011 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
9012 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
9013 VULKAN_HPP_ASSERT( d.vkCmdSetRenderingInputAttachmentIndices &&
9014 "Function <vkCmdSetRenderingInputAttachmentIndices> requires <VK_KHR_dynamic_rendering_local_read> or <VK_VERSION_1_4>" );
9015 # endif
9016
9017 d.vkCmdSetRenderingInputAttachmentIndices( m_commandBuffer, reinterpret_cast<const VkRenderingInputAttachmentIndexInfo *>( &inputAttachmentIndexInfo ) );
9018 }
9019 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9020
9021 //=== VK_KHR_surface ===
9022
9023 // wrapper function for command vkDestroySurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySurfaceKHR.html
9024 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
9025 VULKAN_HPP_INLINE void Instance::destroySurfaceKHR( SurfaceKHR surface, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
9026 {
9027 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
9028 d.vkDestroySurfaceKHR(
9029 static_cast<VkInstance>( m_instance ), static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
9030 }
9031
9032 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9033 // wrapper function for command vkDestroySurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySurfaceKHR.html
9034 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
9035 VULKAN_HPP_INLINE void
9036 Instance::destroySurfaceKHR( SurfaceKHR surface, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
9037 {
9038 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
9039 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
9040 VULKAN_HPP_ASSERT( d.vkDestroySurfaceKHR && "Function <vkDestroySurfaceKHR> requires <VK_KHR_surface>" );
9041 # endif
9042
9043 d.vkDestroySurfaceKHR( m_instance, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
9044 }
9045 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9046
9047 // wrapper function for command vkDestroySurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySurfaceKHR.html
9048 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
9049 VULKAN_HPP_INLINE void Instance::destroy( SurfaceKHR surface, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
9050 {
9051 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
9052 d.vkDestroySurfaceKHR(
9053 static_cast<VkInstance>( m_instance ), static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
9054 }
9055
9056 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9057 // wrapper function for command vkDestroySurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySurfaceKHR.html
9058 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
9059 VULKAN_HPP_INLINE void Instance::destroy( SurfaceKHR surface, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
9060 {
9061 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
9062 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
9063 VULKAN_HPP_ASSERT( d.vkDestroySurfaceKHR && "Function <vkDestroySurfaceKHR> requires <VK_KHR_surface>" );
9064 # endif
9065
9066 d.vkDestroySurfaceKHR( m_instance, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
9067 }
9068 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9069
9070 // wrapper function for command vkGetPhysicalDeviceSurfaceSupportKHR, see
9071 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceSupportKHR.html
9072 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
9073 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
9074 PhysicalDevice::getSurfaceSupportKHR( uint32_t queueFamilyIndex, SurfaceKHR surface, Bool32 * pSupported, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
9075 {
9076 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
9077 return static_cast<Result>( d.vkGetPhysicalDeviceSurfaceSupportKHR(
9078 static_cast<VkPhysicalDevice>( m_physicalDevice ), queueFamilyIndex, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkBool32 *>( pSupported ) ) );
9079 }
9080
9081 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9082 // wrapper function for command vkGetPhysicalDeviceSurfaceSupportKHR, see
9083 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceSupportKHR.html
9084 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
9085 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<Bool32>::type
9086 PhysicalDevice::getSurfaceSupportKHR( uint32_t queueFamilyIndex, SurfaceKHR surface, Dispatch const & d ) const
9087 {
9088 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
9089 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
9090 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfaceSupportKHR && "Function <vkGetPhysicalDeviceSurfaceSupportKHR> requires <VK_KHR_surface>" );
9091 # endif
9092
9093 Bool32 supported;
9094 Result result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceSupportKHR(
9095 m_physicalDevice, queueFamilyIndex, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkBool32 *>( &supported ) ) );
9096 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceSupportKHR" );
9097
9098 return detail::createResultValueType( result, std::move( supported ) );
9099 }
9100 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9101
9102 // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilitiesKHR, see
9103 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilitiesKHR.html
9104 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
9105 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceCapabilitiesKHR( SurfaceKHR surface,
9106 SurfaceCapabilitiesKHR * pSurfaceCapabilities,
9107 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
9108 {
9109 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
9110 return static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilitiesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
9111 static_cast<VkSurfaceKHR>( surface ),
9112 reinterpret_cast<VkSurfaceCapabilitiesKHR *>( pSurfaceCapabilities ) ) );
9113 }
9114
9115 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9116 // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilitiesKHR, see
9117 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilitiesKHR.html
9118 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
9119 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<SurfaceCapabilitiesKHR>::type
9120 PhysicalDevice::getSurfaceCapabilitiesKHR( SurfaceKHR surface, Dispatch const & d ) const
9121 {
9122 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
9123 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
9124 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfaceCapabilitiesKHR && "Function <vkGetPhysicalDeviceSurfaceCapabilitiesKHR> requires <VK_KHR_surface>" );
9125 # endif
9126
9127 SurfaceCapabilitiesKHR surfaceCapabilities;
9128 Result result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
9129 m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkSurfaceCapabilitiesKHR *>( &surfaceCapabilities ) ) );
9130 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilitiesKHR" );
9131
9132 return detail::createResultValueType( result, std::move( surfaceCapabilities ) );
9133 }
9134 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9135
9136 // wrapper function for command vkGetPhysicalDeviceSurfaceFormatsKHR, see
9137 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormatsKHR.html
9138 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
9139 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceFormatsKHR( SurfaceKHR surface,
9140 uint32_t * pSurfaceFormatCount,
9141 SurfaceFormatKHR * pSurfaceFormats,
9142 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
9143 {
9144 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
9145 return static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormatsKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
9146 static_cast<VkSurfaceKHR>( surface ),
9147 pSurfaceFormatCount,
9148 reinterpret_cast<VkSurfaceFormatKHR *>( pSurfaceFormats ) ) );
9149 }
9150
9151 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9152 // wrapper function for command vkGetPhysicalDeviceSurfaceFormatsKHR, see
9153 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormatsKHR.html
9154 template <typename SurfaceFormatKHRAllocator,
9155 typename Dispatch,
9156 typename std::enable_if<std::is_same<typename SurfaceFormatKHRAllocator::value_type, SurfaceFormatKHR>::value, int>::type,
9157 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
9158 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<SurfaceFormatKHR, SurfaceFormatKHRAllocator>>::type
9159 PhysicalDevice::getSurfaceFormatsKHR( SurfaceKHR surface, Dispatch const & d ) const
9160 {
9161 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
9162 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
9163 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfaceFormatsKHR && "Function <vkGetPhysicalDeviceSurfaceFormatsKHR> requires <VK_KHR_surface>" );
9164 # endif
9165
9166 std::vector<SurfaceFormatKHR, SurfaceFormatKHRAllocator> surfaceFormats;
9167 uint32_t surfaceFormatCount;
9168 Result result;
9169 do
9170 {
9171 result =
9172 static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormatsKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &surfaceFormatCount, nullptr ) );
9173 if ( ( result == Result::eSuccess ) && surfaceFormatCount )
9174 {
9175 surfaceFormats.resize( surfaceFormatCount );
9176 result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormatsKHR(
9177 m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &surfaceFormatCount, reinterpret_cast<VkSurfaceFormatKHR *>( surfaceFormats.data() ) ) );
9178 }
9179 } while ( result == Result::eIncomplete );
9180 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceFormatsKHR" );
9181 VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() );
9182 if ( surfaceFormatCount < surfaceFormats.size() )
9183 {
9184 surfaceFormats.resize( surfaceFormatCount );
9185 }
9186 return detail::createResultValueType( result, std::move( surfaceFormats ) );
9187 }
9188
9189 // wrapper function for command vkGetPhysicalDeviceSurfaceFormatsKHR, see
9190 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormatsKHR.html
9191 template <typename SurfaceFormatKHRAllocator,
9192 typename Dispatch,
9193 typename std::enable_if<std::is_same<typename SurfaceFormatKHRAllocator::value_type, SurfaceFormatKHR>::value, int>::type,
9194 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
9195 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<SurfaceFormatKHR, SurfaceFormatKHRAllocator>>::type
9196 PhysicalDevice::getSurfaceFormatsKHR( SurfaceKHR surface, SurfaceFormatKHRAllocator & surfaceFormatKHRAllocator, Dispatch const & d ) const
9197 {
9198 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
9199 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
9200 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfaceFormatsKHR && "Function <vkGetPhysicalDeviceSurfaceFormatsKHR> requires <VK_KHR_surface>" );
9201 # endif
9202
9203 std::vector<SurfaceFormatKHR, SurfaceFormatKHRAllocator> surfaceFormats( surfaceFormatKHRAllocator );
9204 uint32_t surfaceFormatCount;
9205 Result result;
9206 do
9207 {
9208 result =
9209 static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormatsKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &surfaceFormatCount, nullptr ) );
9210 if ( ( result == Result::eSuccess ) && surfaceFormatCount )
9211 {
9212 surfaceFormats.resize( surfaceFormatCount );
9213 result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormatsKHR(
9214 m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &surfaceFormatCount, reinterpret_cast<VkSurfaceFormatKHR *>( surfaceFormats.data() ) ) );
9215 }
9216 } while ( result == Result::eIncomplete );
9217 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceFormatsKHR" );
9218 VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() );
9219 if ( surfaceFormatCount < surfaceFormats.size() )
9220 {
9221 surfaceFormats.resize( surfaceFormatCount );
9222 }
9223 return detail::createResultValueType( result, std::move( surfaceFormats ) );
9224 }
9225 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9226
9227 // wrapper function for command vkGetPhysicalDeviceSurfacePresentModesKHR, see
9228 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfacePresentModesKHR.html
9229 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
9230 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getSurfacePresentModesKHR( SurfaceKHR surface,
9231 uint32_t * pPresentModeCount,
9232 PresentModeKHR * pPresentModes,
9233 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
9234 {
9235 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
9236 return static_cast<Result>( d.vkGetPhysicalDeviceSurfacePresentModesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
9237 static_cast<VkSurfaceKHR>( surface ),
9238 pPresentModeCount,
9239 reinterpret_cast<VkPresentModeKHR *>( pPresentModes ) ) );
9240 }
9241
9242 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9243 // wrapper function for command vkGetPhysicalDeviceSurfacePresentModesKHR, see
9244 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfacePresentModesKHR.html
9245 template <typename PresentModeKHRAllocator,
9246 typename Dispatch,
9247 typename std::enable_if<std::is_same<typename PresentModeKHRAllocator::value_type, PresentModeKHR>::value, int>::type,
9248 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
9249 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<PresentModeKHR, PresentModeKHRAllocator>>::type
9250 PhysicalDevice::getSurfacePresentModesKHR( SurfaceKHR surface, Dispatch const & d ) const
9251 {
9252 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
9253 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
9254 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfacePresentModesKHR && "Function <vkGetPhysicalDeviceSurfacePresentModesKHR> requires <VK_KHR_surface>" );
9255 # endif
9256
9257 std::vector<PresentModeKHR, PresentModeKHRAllocator> presentModes;
9258 uint32_t presentModeCount;
9259 Result result;
9260 do
9261 {
9262 result = static_cast<Result>(
9263 d.vkGetPhysicalDeviceSurfacePresentModesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &presentModeCount, nullptr ) );
9264 if ( ( result == Result::eSuccess ) && presentModeCount )
9265 {
9266 presentModes.resize( presentModeCount );
9267 result = static_cast<Result>( d.vkGetPhysicalDeviceSurfacePresentModesKHR(
9268 m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &presentModeCount, reinterpret_cast<VkPresentModeKHR *>( presentModes.data() ) ) );
9269 }
9270 } while ( result == Result::eIncomplete );
9271 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfacePresentModesKHR" );
9272 VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() );
9273 if ( presentModeCount < presentModes.size() )
9274 {
9275 presentModes.resize( presentModeCount );
9276 }
9277 return detail::createResultValueType( result, std::move( presentModes ) );
9278 }
9279
9280 // wrapper function for command vkGetPhysicalDeviceSurfacePresentModesKHR, see
9281 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfacePresentModesKHR.html
9282 template <typename PresentModeKHRAllocator,
9283 typename Dispatch,
9284 typename std::enable_if<std::is_same<typename PresentModeKHRAllocator::value_type, PresentModeKHR>::value, int>::type,
9285 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
9286 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<PresentModeKHR, PresentModeKHRAllocator>>::type
9287 PhysicalDevice::getSurfacePresentModesKHR( SurfaceKHR surface, PresentModeKHRAllocator & presentModeKHRAllocator, Dispatch const & d ) const
9288 {
9289 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
9290 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
9291 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfacePresentModesKHR && "Function <vkGetPhysicalDeviceSurfacePresentModesKHR> requires <VK_KHR_surface>" );
9292 # endif
9293
9294 std::vector<PresentModeKHR, PresentModeKHRAllocator> presentModes( presentModeKHRAllocator );
9295 uint32_t presentModeCount;
9296 Result result;
9297 do
9298 {
9299 result = static_cast<Result>(
9300 d.vkGetPhysicalDeviceSurfacePresentModesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &presentModeCount, nullptr ) );
9301 if ( ( result == Result::eSuccess ) && presentModeCount )
9302 {
9303 presentModes.resize( presentModeCount );
9304 result = static_cast<Result>( d.vkGetPhysicalDeviceSurfacePresentModesKHR(
9305 m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &presentModeCount, reinterpret_cast<VkPresentModeKHR *>( presentModes.data() ) ) );
9306 }
9307 } while ( result == Result::eIncomplete );
9308 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfacePresentModesKHR" );
9309 VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() );
9310 if ( presentModeCount < presentModes.size() )
9311 {
9312 presentModes.resize( presentModeCount );
9313 }
9314 return detail::createResultValueType( result, std::move( presentModes ) );
9315 }
9316 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9317
9318 //=== VK_KHR_swapchain ===
9319
9320 // wrapper function for command vkCreateSwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSwapchainKHR.html
9321 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
9322 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createSwapchainKHR( const SwapchainCreateInfoKHR * pCreateInfo,
9323 const AllocationCallbacks * pAllocator,
9324 SwapchainKHR * pSwapchain,
9325 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
9326 {
9327 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
9328 return static_cast<Result>( d.vkCreateSwapchainKHR( static_cast<VkDevice>( m_device ),
9329 reinterpret_cast<const VkSwapchainCreateInfoKHR *>( pCreateInfo ),
9330 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
9331 reinterpret_cast<VkSwapchainKHR *>( pSwapchain ) ) );
9332 }
9333
9334 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9335 // wrapper function for command vkCreateSwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSwapchainKHR.html
9336 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
9337 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<SwapchainKHR>::type
9338 Device::createSwapchainKHR( const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
9339 {
9340 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
9341 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
9342 VULKAN_HPP_ASSERT( d.vkCreateSwapchainKHR && "Function <vkCreateSwapchainKHR> requires <VK_KHR_swapchain>" );
9343 # endif
9344
9345 SwapchainKHR swapchain;
9346 Result result = static_cast<Result>( d.vkCreateSwapchainKHR( m_device,
9347 reinterpret_cast<const VkSwapchainCreateInfoKHR *>( &createInfo ),
9348 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
9349 reinterpret_cast<VkSwapchainKHR *>( &swapchain ) ) );
9350 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSwapchainKHR" );
9351
9352 return detail::createResultValueType( result, std::move( swapchain ) );
9353 }
9354
9355 # ifndef VULKAN_HPP_NO_SMART_HANDLE
9356 // wrapper function for command vkCreateSwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSwapchainKHR.html
9357 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
9358 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SwapchainKHR, Dispatch>>::type
9359 Device::createSwapchainKHRUnique( const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
9360 {
9361 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
9362 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
9363 VULKAN_HPP_ASSERT( d.vkCreateSwapchainKHR && "Function <vkCreateSwapchainKHR> requires <VK_KHR_swapchain>" );
9364 # endif
9365
9366 SwapchainKHR swapchain;
9367 Result result = static_cast<Result>( d.vkCreateSwapchainKHR( m_device,
9368 reinterpret_cast<const VkSwapchainCreateInfoKHR *>( &createInfo ),
9369 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
9370 reinterpret_cast<VkSwapchainKHR *>( &swapchain ) ) );
9371 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSwapchainKHRUnique" );
9372
9373 return detail::createResultValueType( result,
9374 UniqueHandle<SwapchainKHR, Dispatch>( swapchain, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
9375 }
9376 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
9377 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9378
9379 // wrapper function for command vkDestroySwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySwapchainKHR.html
9380 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
9381 VULKAN_HPP_INLINE void
9382 Device::destroySwapchainKHR( SwapchainKHR swapchain, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
9383 {
9384 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
9385 d.vkDestroySwapchainKHR(
9386 static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
9387 }
9388
9389 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9390 // wrapper function for command vkDestroySwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySwapchainKHR.html
9391 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
9392 VULKAN_HPP_INLINE void
9393 Device::destroySwapchainKHR( SwapchainKHR swapchain, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
9394 {
9395 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
9396 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
9397 VULKAN_HPP_ASSERT( d.vkDestroySwapchainKHR && "Function <vkDestroySwapchainKHR> requires <VK_KHR_swapchain>" );
9398 # endif
9399
9400 d.vkDestroySwapchainKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
9401 }
9402 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9403
9404 // wrapper function for command vkDestroySwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySwapchainKHR.html
9405 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
9406 VULKAN_HPP_INLINE void Device::destroy( SwapchainKHR swapchain, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
9407 {
9408 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
9409 d.vkDestroySwapchainKHR(
9410 static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
9411 }
9412
9413 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9414 // wrapper function for command vkDestroySwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySwapchainKHR.html
9415 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
9416 VULKAN_HPP_INLINE void Device::destroy( SwapchainKHR swapchain, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
9417 {
9418 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
9419 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
9420 VULKAN_HPP_ASSERT( d.vkDestroySwapchainKHR && "Function <vkDestroySwapchainKHR> requires <VK_KHR_swapchain>" );
9421 # endif
9422
9423 d.vkDestroySwapchainKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
9424 }
9425 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9426
9427 // wrapper function for command vkGetSwapchainImagesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainImagesKHR.html
9428 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
9429 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSwapchainImagesKHR( SwapchainKHR swapchain,
9430 uint32_t * pSwapchainImageCount,
9431 Image * pSwapchainImages,
9432 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
9433 {
9434 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
9435 return static_cast<Result>( d.vkGetSwapchainImagesKHR(
9436 static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( swapchain ), pSwapchainImageCount, reinterpret_cast<VkImage *>( pSwapchainImages ) ) );
9437 }
9438
9439 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9440 // wrapper function for command vkGetSwapchainImagesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainImagesKHR.html
9441 template <typename ImageAllocator,
9442 typename Dispatch,
9443 typename std::enable_if<std::is_same<typename ImageAllocator::value_type, Image>::value, int>::type,
9444 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
9445 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<Image, ImageAllocator>>::type
9446 Device::getSwapchainImagesKHR( SwapchainKHR swapchain, Dispatch const & d ) const
9447 {
9448 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
9449 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
9450 VULKAN_HPP_ASSERT( d.vkGetSwapchainImagesKHR && "Function <vkGetSwapchainImagesKHR> requires <VK_KHR_swapchain>" );
9451 # endif
9452
9453 std::vector<Image, ImageAllocator> swapchainImages;
9454 uint32_t swapchainImageCount;
9455 Result result;
9456 do
9457 {
9458 result = static_cast<Result>( d.vkGetSwapchainImagesKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), &swapchainImageCount, nullptr ) );
9459 if ( ( result == Result::eSuccess ) && swapchainImageCount )
9460 {
9461 swapchainImages.resize( swapchainImageCount );
9462 result = static_cast<Result>( d.vkGetSwapchainImagesKHR(
9463 m_device, static_cast<VkSwapchainKHR>( swapchain ), &swapchainImageCount, reinterpret_cast<VkImage *>( swapchainImages.data() ) ) );
9464 }
9465 } while ( result == Result::eIncomplete );
9466 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSwapchainImagesKHR" );
9467 VULKAN_HPP_ASSERT( swapchainImageCount <= swapchainImages.size() );
9468 if ( swapchainImageCount < swapchainImages.size() )
9469 {
9470 swapchainImages.resize( swapchainImageCount );
9471 }
9472 return detail::createResultValueType( result, std::move( swapchainImages ) );
9473 }
9474
9475 // wrapper function for command vkGetSwapchainImagesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainImagesKHR.html
9476 template <typename ImageAllocator,
9477 typename Dispatch,
9478 typename std::enable_if<std::is_same<typename ImageAllocator::value_type, Image>::value, int>::type,
9479 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
9480 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<Image, ImageAllocator>>::type
9481 Device::getSwapchainImagesKHR( SwapchainKHR swapchain, ImageAllocator & imageAllocator, Dispatch const & d ) const
9482 {
9483 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
9484 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
9485 VULKAN_HPP_ASSERT( d.vkGetSwapchainImagesKHR && "Function <vkGetSwapchainImagesKHR> requires <VK_KHR_swapchain>" );
9486 # endif
9487
9488 std::vector<Image, ImageAllocator> swapchainImages( imageAllocator );
9489 uint32_t swapchainImageCount;
9490 Result result;
9491 do
9492 {
9493 result = static_cast<Result>( d.vkGetSwapchainImagesKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), &swapchainImageCount, nullptr ) );
9494 if ( ( result == Result::eSuccess ) && swapchainImageCount )
9495 {
9496 swapchainImages.resize( swapchainImageCount );
9497 result = static_cast<Result>( d.vkGetSwapchainImagesKHR(
9498 m_device, static_cast<VkSwapchainKHR>( swapchain ), &swapchainImageCount, reinterpret_cast<VkImage *>( swapchainImages.data() ) ) );
9499 }
9500 } while ( result == Result::eIncomplete );
9501 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSwapchainImagesKHR" );
9502 VULKAN_HPP_ASSERT( swapchainImageCount <= swapchainImages.size() );
9503 if ( swapchainImageCount < swapchainImages.size() )
9504 {
9505 swapchainImages.resize( swapchainImageCount );
9506 }
9507 return detail::createResultValueType( result, std::move( swapchainImages ) );
9508 }
9509 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9510
9511 // wrapper function for command vkAcquireNextImageKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireNextImageKHR.html
9512 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
9513 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::acquireNextImageKHR(
9514 SwapchainKHR swapchain, uint64_t timeout, Semaphore semaphore, Fence fence, uint32_t * pImageIndex, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
9515 {
9516 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
9517 return static_cast<Result>( d.vkAcquireNextImageKHR( static_cast<VkDevice>( m_device ),
9518 static_cast<VkSwapchainKHR>( swapchain ),
9519 timeout,
9520 static_cast<VkSemaphore>( semaphore ),
9521 static_cast<VkFence>( fence ),
9522 pImageIndex ) );
9523 }
9524
9525 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9526 // wrapper function for command vkAcquireNextImageKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireNextImageKHR.html
9527 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
9528 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<uint32_t>
9529 Device::acquireNextImageKHR( SwapchainKHR swapchain, uint64_t timeout, Semaphore semaphore, Fence fence, Dispatch const & d ) const
9530 {
9531 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
9532 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
9533 VULKAN_HPP_ASSERT( d.vkAcquireNextImageKHR && "Function <vkAcquireNextImageKHR> requires <VK_KHR_swapchain>" );
9534 # endif
9535
9536 uint32_t imageIndex;
9537 Result result = static_cast<Result>( d.vkAcquireNextImageKHR(
9538 m_device, static_cast<VkSwapchainKHR>( swapchain ), timeout, static_cast<VkSemaphore>( semaphore ), static_cast<VkFence>( fence ), &imageIndex ) );
9539
9540 # if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS )
9541 detail::resultCheck( result,
9542 VULKAN_HPP_NAMESPACE_STRING "::Device::acquireNextImageKHR",
9543 { Result::eSuccess, Result::eTimeout, Result::eNotReady, Result::eSuboptimalKHR, Result::eErrorOutOfDateKHR } );
9544 # else
9545 detail::resultCheck(
9546 result, VULKAN_HPP_NAMESPACE_STRING "::Device::acquireNextImageKHR", { Result::eSuccess, Result::eTimeout, Result::eNotReady, Result::eSuboptimalKHR } );
9547 # endif
9548
9549 return ResultValue<uint32_t>( result, std::move( imageIndex ) );
9550 }
9551 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9552
9553 // wrapper function for command vkQueuePresentKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueuePresentKHR.html
9554 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
9555 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Queue::presentKHR( const PresentInfoKHR * pPresentInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
9556 {
9557 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
9558 return static_cast<Result>( d.vkQueuePresentKHR( static_cast<VkQueue>( m_queue ), reinterpret_cast<const VkPresentInfoKHR *>( pPresentInfo ) ) );
9559 }
9560
9561 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9562 // wrapper function for command vkQueuePresentKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueuePresentKHR.html
9563 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
9564 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Queue::presentKHR( const PresentInfoKHR & presentInfo, Dispatch const & d ) const
9565 {
9566 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
9567 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
9568 VULKAN_HPP_ASSERT( d.vkQueuePresentKHR && "Function <vkQueuePresentKHR> requires <VK_KHR_swapchain>" );
9569 # endif
9570
9571 Result result = static_cast<Result>( d.vkQueuePresentKHR( m_queue, reinterpret_cast<const VkPresentInfoKHR *>( &presentInfo ) ) );
9572
9573 # if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS )
9574 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::presentKHR", { Result::eSuccess, Result::eSuboptimalKHR, Result::eErrorOutOfDateKHR } );
9575 # else
9576 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::presentKHR", { Result::eSuccess, Result::eSuboptimalKHR } );
9577 # endif
9578
9579 return static_cast<Result>( result );
9580 }
9581 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9582
9583 // wrapper function for command vkGetDeviceGroupPresentCapabilitiesKHR, see
9584 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupPresentCapabilitiesKHR.html
9585 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
9586 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getGroupPresentCapabilitiesKHR( DeviceGroupPresentCapabilitiesKHR * pDeviceGroupPresentCapabilities,
9587 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
9588 {
9589 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
9590 return static_cast<Result>( d.vkGetDeviceGroupPresentCapabilitiesKHR(
9591 static_cast<VkDevice>( m_device ), reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHR *>( pDeviceGroupPresentCapabilities ) ) );
9592 }
9593
9594 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9595 // wrapper function for command vkGetDeviceGroupPresentCapabilitiesKHR, see
9596 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupPresentCapabilitiesKHR.html
9597 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
9598 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<DeviceGroupPresentCapabilitiesKHR>::type
9599 Device::getGroupPresentCapabilitiesKHR( Dispatch const & d ) const
9600 {
9601 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
9602 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
9603 VULKAN_HPP_ASSERT( d.vkGetDeviceGroupPresentCapabilitiesKHR &&
9604 "Function <vkGetDeviceGroupPresentCapabilitiesKHR> requires <VK_KHR_device_group> or <VK_KHR_swapchain>" );
9605 # endif
9606
9607 DeviceGroupPresentCapabilitiesKHR deviceGroupPresentCapabilities;
9608 Result result = static_cast<Result>(
9609 d.vkGetDeviceGroupPresentCapabilitiesKHR( m_device, reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHR *>( &deviceGroupPresentCapabilities ) ) );
9610 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getGroupPresentCapabilitiesKHR" );
9611
9612 return detail::createResultValueType( result, std::move( deviceGroupPresentCapabilities ) );
9613 }
9614 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9615
9616 // wrapper function for command vkGetDeviceGroupSurfacePresentModesKHR, see
9617 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupSurfacePresentModesKHR.html
9618 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
9619 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getGroupSurfacePresentModesKHR( SurfaceKHR surface,
9620 DeviceGroupPresentModeFlagsKHR * pModes,
9621 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
9622 {
9623 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
9624 return static_cast<Result>( d.vkGetDeviceGroupSurfacePresentModesKHR(
9625 static_cast<VkDevice>( m_device ), static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkDeviceGroupPresentModeFlagsKHR *>( pModes ) ) );
9626 }
9627
9628 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9629 // wrapper function for command vkGetDeviceGroupSurfacePresentModesKHR, see
9630 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupSurfacePresentModesKHR.html
9631 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
9632 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<DeviceGroupPresentModeFlagsKHR>::type
9633 Device::getGroupSurfacePresentModesKHR( SurfaceKHR surface, Dispatch const & d ) const
9634 {
9635 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
9636 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
9637 VULKAN_HPP_ASSERT( d.vkGetDeviceGroupSurfacePresentModesKHR &&
9638 "Function <vkGetDeviceGroupSurfacePresentModesKHR> requires <VK_KHR_device_group> or <VK_KHR_swapchain>" );
9639 # endif
9640
9641 DeviceGroupPresentModeFlagsKHR modes;
9642 Result result = static_cast<Result>( d.vkGetDeviceGroupSurfacePresentModesKHR(
9643 m_device, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkDeviceGroupPresentModeFlagsKHR *>( &modes ) ) );
9644 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getGroupSurfacePresentModesKHR" );
9645
9646 return detail::createResultValueType( result, std::move( modes ) );
9647 }
9648 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9649
9650 // wrapper function for command vkGetPhysicalDevicePresentRectanglesKHR, see
9651 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDevicePresentRectanglesKHR.html
9652 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
9653 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
9654 PhysicalDevice::getPresentRectanglesKHR( SurfaceKHR surface, uint32_t * pRectCount, Rect2D * pRects, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
9655 {
9656 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
9657 return static_cast<Result>( d.vkGetPhysicalDevicePresentRectanglesKHR(
9658 static_cast<VkPhysicalDevice>( m_physicalDevice ), static_cast<VkSurfaceKHR>( surface ), pRectCount, reinterpret_cast<VkRect2D *>( pRects ) ) );
9659 }
9660
9661 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9662 // wrapper function for command vkGetPhysicalDevicePresentRectanglesKHR, see
9663 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDevicePresentRectanglesKHR.html
9664 template <typename Rect2DAllocator,
9665 typename Dispatch,
9666 typename std::enable_if<std::is_same<typename Rect2DAllocator::value_type, Rect2D>::value, int>::type,
9667 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
9668 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<Rect2D, Rect2DAllocator>>::type
9669 PhysicalDevice::getPresentRectanglesKHR( SurfaceKHR surface, Dispatch const & d ) const
9670 {
9671 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
9672 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
9673 VULKAN_HPP_ASSERT( d.vkGetPhysicalDevicePresentRectanglesKHR &&
9674 "Function <vkGetPhysicalDevicePresentRectanglesKHR> requires <VK_KHR_device_group> or <VK_KHR_swapchain>" );
9675 # endif
9676
9677 std::vector<Rect2D, Rect2DAllocator> rects;
9678 uint32_t rectCount;
9679 Result result;
9680 do
9681 {
9682 result = static_cast<Result>( d.vkGetPhysicalDevicePresentRectanglesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &rectCount, nullptr ) );
9683 if ( ( result == Result::eSuccess ) && rectCount )
9684 {
9685 rects.resize( rectCount );
9686 result = static_cast<Result>( d.vkGetPhysicalDevicePresentRectanglesKHR(
9687 m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &rectCount, reinterpret_cast<VkRect2D *>( rects.data() ) ) );
9688 }
9689 } while ( result == Result::eIncomplete );
9690 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getPresentRectanglesKHR" );
9691 VULKAN_HPP_ASSERT( rectCount <= rects.size() );
9692 if ( rectCount < rects.size() )
9693 {
9694 rects.resize( rectCount );
9695 }
9696 return detail::createResultValueType( result, std::move( rects ) );
9697 }
9698
9699 // wrapper function for command vkGetPhysicalDevicePresentRectanglesKHR, see
9700 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDevicePresentRectanglesKHR.html
9701 template <typename Rect2DAllocator,
9702 typename Dispatch,
9703 typename std::enable_if<std::is_same<typename Rect2DAllocator::value_type, Rect2D>::value, int>::type,
9704 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
9705 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<Rect2D, Rect2DAllocator>>::type
9706 PhysicalDevice::getPresentRectanglesKHR( SurfaceKHR surface, Rect2DAllocator & rect2DAllocator, Dispatch const & d ) const
9707 {
9708 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
9709 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
9710 VULKAN_HPP_ASSERT( d.vkGetPhysicalDevicePresentRectanglesKHR &&
9711 "Function <vkGetPhysicalDevicePresentRectanglesKHR> requires <VK_KHR_device_group> or <VK_KHR_swapchain>" );
9712 # endif
9713
9714 std::vector<Rect2D, Rect2DAllocator> rects( rect2DAllocator );
9715 uint32_t rectCount;
9716 Result result;
9717 do
9718 {
9719 result = static_cast<Result>( d.vkGetPhysicalDevicePresentRectanglesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &rectCount, nullptr ) );
9720 if ( ( result == Result::eSuccess ) && rectCount )
9721 {
9722 rects.resize( rectCount );
9723 result = static_cast<Result>( d.vkGetPhysicalDevicePresentRectanglesKHR(
9724 m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &rectCount, reinterpret_cast<VkRect2D *>( rects.data() ) ) );
9725 }
9726 } while ( result == Result::eIncomplete );
9727 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getPresentRectanglesKHR" );
9728 VULKAN_HPP_ASSERT( rectCount <= rects.size() );
9729 if ( rectCount < rects.size() )
9730 {
9731 rects.resize( rectCount );
9732 }
9733 return detail::createResultValueType( result, std::move( rects ) );
9734 }
9735 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9736
9737 // wrapper function for command vkAcquireNextImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireNextImage2KHR.html
9738 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
9739 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::acquireNextImage2KHR( const AcquireNextImageInfoKHR * pAcquireInfo,
9740 uint32_t * pImageIndex,
9741 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
9742 {
9743 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
9744 return static_cast<Result>(
9745 d.vkAcquireNextImage2KHR( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkAcquireNextImageInfoKHR *>( pAcquireInfo ), pImageIndex ) );
9746 }
9747
9748 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9749 // wrapper function for command vkAcquireNextImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireNextImage2KHR.html
9750 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
9751 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<uint32_t> Device::acquireNextImage2KHR( const AcquireNextImageInfoKHR & acquireInfo,
9752 Dispatch const & d ) const
9753 {
9754 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
9755 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
9756 VULKAN_HPP_ASSERT( d.vkAcquireNextImage2KHR && "Function <vkAcquireNextImage2KHR> requires <VK_KHR_device_group> or <VK_KHR_swapchain>" );
9757 # endif
9758
9759 uint32_t imageIndex;
9760 Result result =
9761 static_cast<Result>( d.vkAcquireNextImage2KHR( m_device, reinterpret_cast<const VkAcquireNextImageInfoKHR *>( &acquireInfo ), &imageIndex ) );
9762
9763 # if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS )
9764 detail::resultCheck( result,
9765 VULKAN_HPP_NAMESPACE_STRING "::Device::acquireNextImage2KHR",
9766 { Result::eSuccess, Result::eTimeout, Result::eNotReady, Result::eSuboptimalKHR, Result::eErrorOutOfDateKHR } );
9767 # else
9768 detail::resultCheck(
9769 result, VULKAN_HPP_NAMESPACE_STRING "::Device::acquireNextImage2KHR", { Result::eSuccess, Result::eTimeout, Result::eNotReady, Result::eSuboptimalKHR } );
9770 # endif
9771
9772 return ResultValue<uint32_t>( result, std::move( imageIndex ) );
9773 }
9774 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9775
9776 //=== VK_KHR_display ===
9777
9778 // wrapper function for command vkGetPhysicalDeviceDisplayPropertiesKHR, see
9779 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPropertiesKHR.html
9780 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
9781 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPropertiesKHR( uint32_t * pPropertyCount,
9782 DisplayPropertiesKHR * pProperties,
9783 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
9784 {
9785 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
9786 return static_cast<Result>( d.vkGetPhysicalDeviceDisplayPropertiesKHR(
9787 static_cast<VkPhysicalDevice>( m_physicalDevice ), pPropertyCount, reinterpret_cast<VkDisplayPropertiesKHR *>( pProperties ) ) );
9788 }
9789
9790 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9791 // wrapper function for command vkGetPhysicalDeviceDisplayPropertiesKHR, see
9792 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPropertiesKHR.html
9793 template <typename DisplayPropertiesKHRAllocator,
9794 typename Dispatch,
9795 typename std::enable_if<std::is_same<typename DisplayPropertiesKHRAllocator::value_type, DisplayPropertiesKHR>::value, int>::type,
9796 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
9797 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayPropertiesKHR, DisplayPropertiesKHRAllocator>>::type
9798 PhysicalDevice::getDisplayPropertiesKHR( Dispatch const & d ) const
9799 {
9800 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
9801 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
9802 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceDisplayPropertiesKHR && "Function <vkGetPhysicalDeviceDisplayPropertiesKHR> requires <VK_KHR_display>" );
9803 # endif
9804
9805 std::vector<DisplayPropertiesKHR, DisplayPropertiesKHRAllocator> properties;
9806 uint32_t propertyCount;
9807 Result result;
9808 do
9809 {
9810 result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPropertiesKHR( m_physicalDevice, &propertyCount, nullptr ) );
9811 if ( ( result == Result::eSuccess ) && propertyCount )
9812 {
9813 properties.resize( propertyCount );
9814 result = static_cast<Result>(
9815 d.vkGetPhysicalDeviceDisplayPropertiesKHR( m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayPropertiesKHR *>( properties.data() ) ) );
9816 }
9817 } while ( result == Result::eIncomplete );
9818 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPropertiesKHR" );
9819 VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
9820 if ( propertyCount < properties.size() )
9821 {
9822 properties.resize( propertyCount );
9823 }
9824 return detail::createResultValueType( result, std::move( properties ) );
9825 }
9826
9827 // wrapper function for command vkGetPhysicalDeviceDisplayPropertiesKHR, see
9828 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPropertiesKHR.html
9829 template <typename DisplayPropertiesKHRAllocator,
9830 typename Dispatch,
9831 typename std::enable_if<std::is_same<typename DisplayPropertiesKHRAllocator::value_type, DisplayPropertiesKHR>::value, int>::type,
9832 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
9833 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayPropertiesKHR, DisplayPropertiesKHRAllocator>>::type
9834 PhysicalDevice::getDisplayPropertiesKHR( DisplayPropertiesKHRAllocator & displayPropertiesKHRAllocator, Dispatch const & d ) const
9835 {
9836 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
9837 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
9838 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceDisplayPropertiesKHR && "Function <vkGetPhysicalDeviceDisplayPropertiesKHR> requires <VK_KHR_display>" );
9839 # endif
9840
9841 std::vector<DisplayPropertiesKHR, DisplayPropertiesKHRAllocator> properties( displayPropertiesKHRAllocator );
9842 uint32_t propertyCount;
9843 Result result;
9844 do
9845 {
9846 result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPropertiesKHR( m_physicalDevice, &propertyCount, nullptr ) );
9847 if ( ( result == Result::eSuccess ) && propertyCount )
9848 {
9849 properties.resize( propertyCount );
9850 result = static_cast<Result>(
9851 d.vkGetPhysicalDeviceDisplayPropertiesKHR( m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayPropertiesKHR *>( properties.data() ) ) );
9852 }
9853 } while ( result == Result::eIncomplete );
9854 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPropertiesKHR" );
9855 VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
9856 if ( propertyCount < properties.size() )
9857 {
9858 properties.resize( propertyCount );
9859 }
9860 return detail::createResultValueType( result, std::move( properties ) );
9861 }
9862 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9863
9864 // wrapper function for command vkGetPhysicalDeviceDisplayPlanePropertiesKHR, see
9865 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPlanePropertiesKHR.html
9866 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
9867 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlanePropertiesKHR( uint32_t * pPropertyCount,
9868 DisplayPlanePropertiesKHR * pProperties,
9869 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
9870 {
9871 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
9872 return static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
9873 static_cast<VkPhysicalDevice>( m_physicalDevice ), pPropertyCount, reinterpret_cast<VkDisplayPlanePropertiesKHR *>( pProperties ) ) );
9874 }
9875
9876 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9877 // wrapper function for command vkGetPhysicalDeviceDisplayPlanePropertiesKHR, see
9878 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPlanePropertiesKHR.html
9879 template <typename DisplayPlanePropertiesKHRAllocator,
9880 typename Dispatch,
9881 typename std::enable_if<std::is_same<typename DisplayPlanePropertiesKHRAllocator::value_type, DisplayPlanePropertiesKHR>::value, int>::type,
9882 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
9883 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayPlanePropertiesKHR, DisplayPlanePropertiesKHRAllocator>>::type
9884 PhysicalDevice::getDisplayPlanePropertiesKHR( Dispatch const & d ) const
9885 {
9886 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
9887 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
9888 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR && "Function <vkGetPhysicalDeviceDisplayPlanePropertiesKHR> requires <VK_KHR_display>" );
9889 # endif
9890
9891 std::vector<DisplayPlanePropertiesKHR, DisplayPlanePropertiesKHRAllocator> properties;
9892 uint32_t propertyCount;
9893 Result result;
9894 do
9895 {
9896 result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR( m_physicalDevice, &propertyCount, nullptr ) );
9897 if ( ( result == Result::eSuccess ) && propertyCount )
9898 {
9899 properties.resize( propertyCount );
9900 result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
9901 m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayPlanePropertiesKHR *>( properties.data() ) ) );
9902 }
9903 } while ( result == Result::eIncomplete );
9904 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlanePropertiesKHR" );
9905 VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
9906 if ( propertyCount < properties.size() )
9907 {
9908 properties.resize( propertyCount );
9909 }
9910 return detail::createResultValueType( result, std::move( properties ) );
9911 }
9912
9913 // wrapper function for command vkGetPhysicalDeviceDisplayPlanePropertiesKHR, see
9914 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPlanePropertiesKHR.html
9915 template <typename DisplayPlanePropertiesKHRAllocator,
9916 typename Dispatch,
9917 typename std::enable_if<std::is_same<typename DisplayPlanePropertiesKHRAllocator::value_type, DisplayPlanePropertiesKHR>::value, int>::type,
9918 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
9919 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayPlanePropertiesKHR, DisplayPlanePropertiesKHRAllocator>>::type
9920 PhysicalDevice::getDisplayPlanePropertiesKHR( DisplayPlanePropertiesKHRAllocator & displayPlanePropertiesKHRAllocator, Dispatch const & d ) const
9921 {
9922 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
9923 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
9924 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR && "Function <vkGetPhysicalDeviceDisplayPlanePropertiesKHR> requires <VK_KHR_display>" );
9925 # endif
9926
9927 std::vector<DisplayPlanePropertiesKHR, DisplayPlanePropertiesKHRAllocator> properties( displayPlanePropertiesKHRAllocator );
9928 uint32_t propertyCount;
9929 Result result;
9930 do
9931 {
9932 result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR( m_physicalDevice, &propertyCount, nullptr ) );
9933 if ( ( result == Result::eSuccess ) && propertyCount )
9934 {
9935 properties.resize( propertyCount );
9936 result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
9937 m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayPlanePropertiesKHR *>( properties.data() ) ) );
9938 }
9939 } while ( result == Result::eIncomplete );
9940 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlanePropertiesKHR" );
9941 VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
9942 if ( propertyCount < properties.size() )
9943 {
9944 properties.resize( propertyCount );
9945 }
9946 return detail::createResultValueType( result, std::move( properties ) );
9947 }
9948 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9949
9950 // wrapper function for command vkGetDisplayPlaneSupportedDisplaysKHR, see
9951 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneSupportedDisplaysKHR.html
9952 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
9953 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex,
9954 uint32_t * pDisplayCount,
9955 DisplayKHR * pDisplays,
9956 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
9957 {
9958 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
9959 return static_cast<Result>( d.vkGetDisplayPlaneSupportedDisplaysKHR(
9960 static_cast<VkPhysicalDevice>( m_physicalDevice ), planeIndex, pDisplayCount, reinterpret_cast<VkDisplayKHR *>( pDisplays ) ) );
9961 }
9962
9963 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9964 // wrapper function for command vkGetDisplayPlaneSupportedDisplaysKHR, see
9965 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneSupportedDisplaysKHR.html
9966 template <typename DisplayKHRAllocator,
9967 typename Dispatch,
9968 typename std::enable_if<std::is_same<typename DisplayKHRAllocator::value_type, DisplayKHR>::value, int>::type,
9969 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
9970 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayKHR, DisplayKHRAllocator>>::type
9971 PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, Dispatch const & d ) const
9972 {
9973 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
9974 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
9975 VULKAN_HPP_ASSERT( d.vkGetDisplayPlaneSupportedDisplaysKHR && "Function <vkGetDisplayPlaneSupportedDisplaysKHR> requires <VK_KHR_display>" );
9976 # endif
9977
9978 std::vector<DisplayKHR, DisplayKHRAllocator> displays;
9979 uint32_t displayCount;
9980 Result result;
9981 do
9982 {
9983 result = static_cast<Result>( d.vkGetDisplayPlaneSupportedDisplaysKHR( m_physicalDevice, planeIndex, &displayCount, nullptr ) );
9984 if ( ( result == Result::eSuccess ) && displayCount )
9985 {
9986 displays.resize( displayCount );
9987 result = static_cast<Result>(
9988 d.vkGetDisplayPlaneSupportedDisplaysKHR( m_physicalDevice, planeIndex, &displayCount, reinterpret_cast<VkDisplayKHR *>( displays.data() ) ) );
9989 }
9990 } while ( result == Result::eIncomplete );
9991 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR" );
9992 VULKAN_HPP_ASSERT( displayCount <= displays.size() );
9993 if ( displayCount < displays.size() )
9994 {
9995 displays.resize( displayCount );
9996 }
9997 return detail::createResultValueType( result, std::move( displays ) );
9998 }
9999
10000 // wrapper function for command vkGetDisplayPlaneSupportedDisplaysKHR, see
10001 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneSupportedDisplaysKHR.html
10002 template <typename DisplayKHRAllocator,
10003 typename Dispatch,
10004 typename std::enable_if<std::is_same<typename DisplayKHRAllocator::value_type, DisplayKHR>::value, int>::type,
10005 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
10006 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayKHR, DisplayKHRAllocator>>::type
10007 PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, DisplayKHRAllocator & displayKHRAllocator, Dispatch const & d ) const
10008 {
10009 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
10010 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
10011 VULKAN_HPP_ASSERT( d.vkGetDisplayPlaneSupportedDisplaysKHR && "Function <vkGetDisplayPlaneSupportedDisplaysKHR> requires <VK_KHR_display>" );
10012 # endif
10013
10014 std::vector<DisplayKHR, DisplayKHRAllocator> displays( displayKHRAllocator );
10015 uint32_t displayCount;
10016 Result result;
10017 do
10018 {
10019 result = static_cast<Result>( d.vkGetDisplayPlaneSupportedDisplaysKHR( m_physicalDevice, planeIndex, &displayCount, nullptr ) );
10020 if ( ( result == Result::eSuccess ) && displayCount )
10021 {
10022 displays.resize( displayCount );
10023 result = static_cast<Result>(
10024 d.vkGetDisplayPlaneSupportedDisplaysKHR( m_physicalDevice, planeIndex, &displayCount, reinterpret_cast<VkDisplayKHR *>( displays.data() ) ) );
10025 }
10026 } while ( result == Result::eIncomplete );
10027 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR" );
10028 VULKAN_HPP_ASSERT( displayCount <= displays.size() );
10029 if ( displayCount < displays.size() )
10030 {
10031 displays.resize( displayCount );
10032 }
10033 return detail::createResultValueType( result, std::move( displays ) );
10034 }
10035 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10036
10037 // wrapper function for command vkGetDisplayModePropertiesKHR, see
10038 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModePropertiesKHR.html
10039 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
10040 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayModePropertiesKHR( DisplayKHR display,
10041 uint32_t * pPropertyCount,
10042 DisplayModePropertiesKHR * pProperties,
10043 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
10044 {
10045 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
10046 return static_cast<Result>( d.vkGetDisplayModePropertiesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
10047 static_cast<VkDisplayKHR>( display ),
10048 pPropertyCount,
10049 reinterpret_cast<VkDisplayModePropertiesKHR *>( pProperties ) ) );
10050 }
10051
10052 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10053 // wrapper function for command vkGetDisplayModePropertiesKHR, see
10054 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModePropertiesKHR.html
10055 template <typename DisplayModePropertiesKHRAllocator,
10056 typename Dispatch,
10057 typename std::enable_if<std::is_same<typename DisplayModePropertiesKHRAllocator::value_type, DisplayModePropertiesKHR>::value, int>::type,
10058 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
10059 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayModePropertiesKHR, DisplayModePropertiesKHRAllocator>>::type
10060 PhysicalDevice::getDisplayModePropertiesKHR( DisplayKHR display, Dispatch const & d ) const
10061 {
10062 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
10063 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
10064 VULKAN_HPP_ASSERT( d.vkGetDisplayModePropertiesKHR && "Function <vkGetDisplayModePropertiesKHR> requires <VK_KHR_display>" );
10065 # endif
10066
10067 std::vector<DisplayModePropertiesKHR, DisplayModePropertiesKHRAllocator> properties;
10068 uint32_t propertyCount;
10069 Result result;
10070 do
10071 {
10072 result = static_cast<Result>( d.vkGetDisplayModePropertiesKHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, nullptr ) );
10073 if ( ( result == Result::eSuccess ) && propertyCount )
10074 {
10075 properties.resize( propertyCount );
10076 result = static_cast<Result>( d.vkGetDisplayModePropertiesKHR(
10077 m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, reinterpret_cast<VkDisplayModePropertiesKHR *>( properties.data() ) ) );
10078 }
10079 } while ( result == Result::eIncomplete );
10080 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayModePropertiesKHR" );
10081 VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
10082 if ( propertyCount < properties.size() )
10083 {
10084 properties.resize( propertyCount );
10085 }
10086 return detail::createResultValueType( result, std::move( properties ) );
10087 }
10088
10089 // wrapper function for command vkGetDisplayModePropertiesKHR, see
10090 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModePropertiesKHR.html
10091 template <typename DisplayModePropertiesKHRAllocator,
10092 typename Dispatch,
10093 typename std::enable_if<std::is_same<typename DisplayModePropertiesKHRAllocator::value_type, DisplayModePropertiesKHR>::value, int>::type,
10094 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
10095 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayModePropertiesKHR, DisplayModePropertiesKHRAllocator>>::type
10096 PhysicalDevice::getDisplayModePropertiesKHR( DisplayKHR display,
10097 DisplayModePropertiesKHRAllocator & displayModePropertiesKHRAllocator,
10098 Dispatch const & d ) const
10099 {
10100 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
10101 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
10102 VULKAN_HPP_ASSERT( d.vkGetDisplayModePropertiesKHR && "Function <vkGetDisplayModePropertiesKHR> requires <VK_KHR_display>" );
10103 # endif
10104
10105 std::vector<DisplayModePropertiesKHR, DisplayModePropertiesKHRAllocator> properties( displayModePropertiesKHRAllocator );
10106 uint32_t propertyCount;
10107 Result result;
10108 do
10109 {
10110 result = static_cast<Result>( d.vkGetDisplayModePropertiesKHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, nullptr ) );
10111 if ( ( result == Result::eSuccess ) && propertyCount )
10112 {
10113 properties.resize( propertyCount );
10114 result = static_cast<Result>( d.vkGetDisplayModePropertiesKHR(
10115 m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, reinterpret_cast<VkDisplayModePropertiesKHR *>( properties.data() ) ) );
10116 }
10117 } while ( result == Result::eIncomplete );
10118 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayModePropertiesKHR" );
10119 VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
10120 if ( propertyCount < properties.size() )
10121 {
10122 properties.resize( propertyCount );
10123 }
10124 return detail::createResultValueType( result, std::move( properties ) );
10125 }
10126 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10127
10128 // wrapper function for command vkCreateDisplayModeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDisplayModeKHR.html
10129 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
10130 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::createDisplayModeKHR( DisplayKHR display,
10131 const DisplayModeCreateInfoKHR * pCreateInfo,
10132 const AllocationCallbacks * pAllocator,
10133 DisplayModeKHR * pMode,
10134 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
10135 {
10136 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
10137 return static_cast<Result>( d.vkCreateDisplayModeKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
10138 static_cast<VkDisplayKHR>( display ),
10139 reinterpret_cast<const VkDisplayModeCreateInfoKHR *>( pCreateInfo ),
10140 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
10141 reinterpret_cast<VkDisplayModeKHR *>( pMode ) ) );
10142 }
10143
10144 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10145 // wrapper function for command vkCreateDisplayModeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDisplayModeKHR.html
10146 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
10147 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<DisplayModeKHR>::type PhysicalDevice::createDisplayModeKHR(
10148 DisplayKHR display, const DisplayModeCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
10149 {
10150 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
10151 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
10152 VULKAN_HPP_ASSERT( d.vkCreateDisplayModeKHR && "Function <vkCreateDisplayModeKHR> requires <VK_KHR_display>" );
10153 # endif
10154
10155 DisplayModeKHR mode;
10156 Result result = static_cast<Result>( d.vkCreateDisplayModeKHR( m_physicalDevice,
10157 static_cast<VkDisplayKHR>( display ),
10158 reinterpret_cast<const VkDisplayModeCreateInfoKHR *>( &createInfo ),
10159 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
10160 reinterpret_cast<VkDisplayModeKHR *>( &mode ) ) );
10161 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::createDisplayModeKHR" );
10162
10163 return detail::createResultValueType( result, std::move( mode ) );
10164 }
10165
10166 # ifndef VULKAN_HPP_NO_SMART_HANDLE
10167 // wrapper function for command vkCreateDisplayModeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDisplayModeKHR.html
10168 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
10169 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<DisplayModeKHR, Dispatch>>::type PhysicalDevice::createDisplayModeKHRUnique(
10170 DisplayKHR display, const DisplayModeCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
10171 {
10172 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
10173 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
10174 VULKAN_HPP_ASSERT( d.vkCreateDisplayModeKHR && "Function <vkCreateDisplayModeKHR> requires <VK_KHR_display>" );
10175 # endif
10176
10177 DisplayModeKHR mode;
10178 Result result = static_cast<Result>( d.vkCreateDisplayModeKHR( m_physicalDevice,
10179 static_cast<VkDisplayKHR>( display ),
10180 reinterpret_cast<const VkDisplayModeCreateInfoKHR *>( &createInfo ),
10181 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
10182 reinterpret_cast<VkDisplayModeKHR *>( &mode ) ) );
10183 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::createDisplayModeKHRUnique" );
10184
10185 return detail::createResultValueType(
10186 result, UniqueHandle<DisplayModeKHR, Dispatch>( mode, detail::ObjectDestroy<PhysicalDevice, Dispatch>( *this, allocator, d ) ) );
10187 }
10188 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
10189 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10190
10191 // wrapper function for command vkGetDisplayPlaneCapabilitiesKHR, see
10192 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneCapabilitiesKHR.html
10193 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
10194 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlaneCapabilitiesKHR( DisplayModeKHR mode,
10195 uint32_t planeIndex,
10196 DisplayPlaneCapabilitiesKHR * pCapabilities,
10197 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
10198 {
10199 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
10200 return static_cast<Result>( d.vkGetDisplayPlaneCapabilitiesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
10201 static_cast<VkDisplayModeKHR>( mode ),
10202 planeIndex,
10203 reinterpret_cast<VkDisplayPlaneCapabilitiesKHR *>( pCapabilities ) ) );
10204 }
10205
10206 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10207 // wrapper function for command vkGetDisplayPlaneCapabilitiesKHR, see
10208 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneCapabilitiesKHR.html
10209 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
10210 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<DisplayPlaneCapabilitiesKHR>::type
10211 PhysicalDevice::getDisplayPlaneCapabilitiesKHR( DisplayModeKHR mode, uint32_t planeIndex, Dispatch const & d ) const
10212 {
10213 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
10214 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
10215 VULKAN_HPP_ASSERT( d.vkGetDisplayPlaneCapabilitiesKHR && "Function <vkGetDisplayPlaneCapabilitiesKHR> requires <VK_KHR_display>" );
10216 # endif
10217
10218 DisplayPlaneCapabilitiesKHR capabilities;
10219 Result result = static_cast<Result>( d.vkGetDisplayPlaneCapabilitiesKHR(
10220 m_physicalDevice, static_cast<VkDisplayModeKHR>( mode ), planeIndex, reinterpret_cast<VkDisplayPlaneCapabilitiesKHR *>( &capabilities ) ) );
10221 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneCapabilitiesKHR" );
10222
10223 return detail::createResultValueType( result, std::move( capabilities ) );
10224 }
10225 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10226
10227 // wrapper function for command vkCreateDisplayPlaneSurfaceKHR, see
10228 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDisplayPlaneSurfaceKHR.html
10229 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
10230 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createDisplayPlaneSurfaceKHR( const DisplaySurfaceCreateInfoKHR * pCreateInfo,
10231 const AllocationCallbacks * pAllocator,
10232 SurfaceKHR * pSurface,
10233 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
10234 {
10235 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
10236 return static_cast<Result>( d.vkCreateDisplayPlaneSurfaceKHR( static_cast<VkInstance>( m_instance ),
10237 reinterpret_cast<const VkDisplaySurfaceCreateInfoKHR *>( pCreateInfo ),
10238 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
10239 reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) );
10240 }
10241
10242 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10243 // wrapper function for command vkCreateDisplayPlaneSurfaceKHR, see
10244 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDisplayPlaneSurfaceKHR.html
10245 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
10246 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<SurfaceKHR>::type Instance::createDisplayPlaneSurfaceKHR(
10247 const DisplaySurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
10248 {
10249 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
10250 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
10251 VULKAN_HPP_ASSERT( d.vkCreateDisplayPlaneSurfaceKHR && "Function <vkCreateDisplayPlaneSurfaceKHR> requires <VK_KHR_display>" );
10252 # endif
10253
10254 SurfaceKHR surface;
10255 Result result = static_cast<Result>( d.vkCreateDisplayPlaneSurfaceKHR( m_instance,
10256 reinterpret_cast<const VkDisplaySurfaceCreateInfoKHR *>( &createInfo ),
10257 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
10258 reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
10259 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDisplayPlaneSurfaceKHR" );
10260
10261 return detail::createResultValueType( result, std::move( surface ) );
10262 }
10263
10264 # ifndef VULKAN_HPP_NO_SMART_HANDLE
10265 // wrapper function for command vkCreateDisplayPlaneSurfaceKHR, see
10266 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDisplayPlaneSurfaceKHR.html
10267 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
10268 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type Instance::createDisplayPlaneSurfaceKHRUnique(
10269 const DisplaySurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
10270 {
10271 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
10272 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
10273 VULKAN_HPP_ASSERT( d.vkCreateDisplayPlaneSurfaceKHR && "Function <vkCreateDisplayPlaneSurfaceKHR> requires <VK_KHR_display>" );
10274 # endif
10275
10276 SurfaceKHR surface;
10277 Result result = static_cast<Result>( d.vkCreateDisplayPlaneSurfaceKHR( m_instance,
10278 reinterpret_cast<const VkDisplaySurfaceCreateInfoKHR *>( &createInfo ),
10279 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
10280 reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
10281 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDisplayPlaneSurfaceKHRUnique" );
10282
10283 return detail::createResultValueType( result,
10284 UniqueHandle<SurfaceKHR, Dispatch>( surface, detail::ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) );
10285 }
10286 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
10287 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10288
10289 //=== VK_KHR_display_swapchain ===
10290
10291 // wrapper function for command vkCreateSharedSwapchainsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSharedSwapchainsKHR.html
10292 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
10293 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createSharedSwapchainsKHR( uint32_t swapchainCount,
10294 const SwapchainCreateInfoKHR * pCreateInfos,
10295 const AllocationCallbacks * pAllocator,
10296 SwapchainKHR * pSwapchains,
10297 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
10298 {
10299 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
10300 return static_cast<Result>( d.vkCreateSharedSwapchainsKHR( static_cast<VkDevice>( m_device ),
10301 swapchainCount,
10302 reinterpret_cast<const VkSwapchainCreateInfoKHR *>( pCreateInfos ),
10303 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
10304 reinterpret_cast<VkSwapchainKHR *>( pSwapchains ) ) );
10305 }
10306
10307 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10308 // wrapper function for command vkCreateSharedSwapchainsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSharedSwapchainsKHR.html
10309 template <typename SwapchainKHRAllocator,
10310 typename Dispatch,
10311 typename std::enable_if<std::is_same<typename SwapchainKHRAllocator::value_type, SwapchainKHR>::value, int>::type,
10312 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
10313 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<SwapchainKHR, SwapchainKHRAllocator>>::type Device::createSharedSwapchainsKHR(
10314 ArrayProxy<const SwapchainCreateInfoKHR> const & createInfos, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
10315 {
10316 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
10317 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
10318 VULKAN_HPP_ASSERT( d.vkCreateSharedSwapchainsKHR && "Function <vkCreateSharedSwapchainsKHR> requires <VK_KHR_display_swapchain>" );
10319 # endif
10320
10321 std::vector<SwapchainKHR, SwapchainKHRAllocator> swapchains( createInfos.size() );
10322 Result result = static_cast<Result>( d.vkCreateSharedSwapchainsKHR( m_device,
10323 createInfos.size(),
10324 reinterpret_cast<const VkSwapchainCreateInfoKHR *>( createInfos.data() ),
10325 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
10326 reinterpret_cast<VkSwapchainKHR *>( swapchains.data() ) ) );
10327 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHR" );
10328
10329 return detail::createResultValueType( result, std::move( swapchains ) );
10330 }
10331
10332 // wrapper function for command vkCreateSharedSwapchainsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSharedSwapchainsKHR.html
10333 template <typename SwapchainKHRAllocator,
10334 typename Dispatch,
10335 typename std::enable_if<std::is_same<typename SwapchainKHRAllocator::value_type, SwapchainKHR>::value, int>::type,
10336 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
10337 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<SwapchainKHR, SwapchainKHRAllocator>>::type
10338 Device::createSharedSwapchainsKHR( ArrayProxy<const SwapchainCreateInfoKHR> const & createInfos,
10339 Optional<const AllocationCallbacks> allocator,
10340 SwapchainKHRAllocator & swapchainKHRAllocator,
10341 Dispatch const & d ) const
10342 {
10343 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
10344 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
10345 VULKAN_HPP_ASSERT( d.vkCreateSharedSwapchainsKHR && "Function <vkCreateSharedSwapchainsKHR> requires <VK_KHR_display_swapchain>" );
10346 # endif
10347
10348 std::vector<SwapchainKHR, SwapchainKHRAllocator> swapchains( createInfos.size(), swapchainKHRAllocator );
10349 Result result = static_cast<Result>( d.vkCreateSharedSwapchainsKHR( m_device,
10350 createInfos.size(),
10351 reinterpret_cast<const VkSwapchainCreateInfoKHR *>( createInfos.data() ),
10352 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
10353 reinterpret_cast<VkSwapchainKHR *>( swapchains.data() ) ) );
10354 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHR" );
10355
10356 return detail::createResultValueType( result, std::move( swapchains ) );
10357 }
10358
10359 // wrapper function for command vkCreateSharedSwapchainsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSharedSwapchainsKHR.html
10360 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
10361 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<SwapchainKHR>::type
10362 Device::createSharedSwapchainKHR( const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
10363 {
10364 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
10365 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
10366 VULKAN_HPP_ASSERT( d.vkCreateSharedSwapchainsKHR && "Function <vkCreateSharedSwapchainsKHR> requires <VK_KHR_display_swapchain>" );
10367 # endif
10368
10369 SwapchainKHR swapchain;
10370 Result result = static_cast<Result>( d.vkCreateSharedSwapchainsKHR( m_device,
10371 1,
10372 reinterpret_cast<const VkSwapchainCreateInfoKHR *>( &createInfo ),
10373 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
10374 reinterpret_cast<VkSwapchainKHR *>( &swapchain ) ) );
10375 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainKHR" );
10376
10377 return detail::createResultValueType( result, std::move( swapchain ) );
10378 }
10379
10380 # ifndef VULKAN_HPP_NO_SMART_HANDLE
10381 // wrapper function for command vkCreateSharedSwapchainsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSharedSwapchainsKHR.html
10382 template <typename Dispatch,
10383 typename SwapchainKHRAllocator,
10384 typename std::enable_if<std::is_same<typename SwapchainKHRAllocator::value_type, UniqueHandle<SwapchainKHR, Dispatch>>::value, int>::type,
10385 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
10386 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<SwapchainKHR, Dispatch>, SwapchainKHRAllocator>>::type
10387 Device::createSharedSwapchainsKHRUnique( ArrayProxy<const SwapchainCreateInfoKHR> const & createInfos,
10388 Optional<const AllocationCallbacks> allocator,
10389 Dispatch const & d ) const
10390 {
10391 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
10392 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
10393 VULKAN_HPP_ASSERT( d.vkCreateSharedSwapchainsKHR && "Function <vkCreateSharedSwapchainsKHR> requires <VK_KHR_display_swapchain>" );
10394 # endif
10395
10396 std::vector<SwapchainKHR> swapchains( createInfos.size() );
10397 Result result = static_cast<Result>( d.vkCreateSharedSwapchainsKHR( m_device,
10398 createInfos.size(),
10399 reinterpret_cast<const VkSwapchainCreateInfoKHR *>( createInfos.data() ),
10400 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
10401 reinterpret_cast<VkSwapchainKHR *>( swapchains.data() ) ) );
10402 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHRUnique" );
10403 std::vector<UniqueHandle<SwapchainKHR, Dispatch>, SwapchainKHRAllocator> uniqueSwapchains;
10404 uniqueSwapchains.reserve( createInfos.size() );
10405 detail::ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
10406 for ( auto const & swapchain : swapchains )
10407 {
10408 uniqueSwapchains.push_back( UniqueHandle<SwapchainKHR, Dispatch>( swapchain, deleter ) );
10409 }
10410 return detail::createResultValueType( result, std::move( uniqueSwapchains ) );
10411 }
10412
10413 // wrapper function for command vkCreateSharedSwapchainsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSharedSwapchainsKHR.html
10414 template <typename Dispatch,
10415 typename SwapchainKHRAllocator,
10416 typename std::enable_if<std::is_same<typename SwapchainKHRAllocator::value_type, UniqueHandle<SwapchainKHR, Dispatch>>::value, int>::type,
10417 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
10418 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<SwapchainKHR, Dispatch>, SwapchainKHRAllocator>>::type
10419 Device::createSharedSwapchainsKHRUnique( ArrayProxy<const SwapchainCreateInfoKHR> const & createInfos,
10420 Optional<const AllocationCallbacks> allocator,
10421 SwapchainKHRAllocator & swapchainKHRAllocator,
10422 Dispatch const & d ) const
10423 {
10424 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
10425 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
10426 VULKAN_HPP_ASSERT( d.vkCreateSharedSwapchainsKHR && "Function <vkCreateSharedSwapchainsKHR> requires <VK_KHR_display_swapchain>" );
10427 # endif
10428
10429 std::vector<SwapchainKHR> swapchains( createInfos.size() );
10430 Result result = static_cast<Result>( d.vkCreateSharedSwapchainsKHR( m_device,
10431 createInfos.size(),
10432 reinterpret_cast<const VkSwapchainCreateInfoKHR *>( createInfos.data() ),
10433 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
10434 reinterpret_cast<VkSwapchainKHR *>( swapchains.data() ) ) );
10435 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHRUnique" );
10436 std::vector<UniqueHandle<SwapchainKHR, Dispatch>, SwapchainKHRAllocator> uniqueSwapchains( swapchainKHRAllocator );
10437 uniqueSwapchains.reserve( createInfos.size() );
10438 detail::ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
10439 for ( auto const & swapchain : swapchains )
10440 {
10441 uniqueSwapchains.push_back( UniqueHandle<SwapchainKHR, Dispatch>( swapchain, deleter ) );
10442 }
10443 return detail::createResultValueType( result, std::move( uniqueSwapchains ) );
10444 }
10445
10446 // wrapper function for command vkCreateSharedSwapchainsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSharedSwapchainsKHR.html
10447 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
10448 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SwapchainKHR, Dispatch>>::type
10449 Device::createSharedSwapchainKHRUnique( const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
10450 {
10451 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
10452 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
10453 VULKAN_HPP_ASSERT( d.vkCreateSharedSwapchainsKHR && "Function <vkCreateSharedSwapchainsKHR> requires <VK_KHR_display_swapchain>" );
10454 # endif
10455
10456 SwapchainKHR swapchain;
10457 Result result = static_cast<Result>( d.vkCreateSharedSwapchainsKHR( m_device,
10458 1,
10459 reinterpret_cast<const VkSwapchainCreateInfoKHR *>( &createInfo ),
10460 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
10461 reinterpret_cast<VkSwapchainKHR *>( &swapchain ) ) );
10462 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainKHRUnique" );
10463
10464 return detail::createResultValueType( result,
10465 UniqueHandle<SwapchainKHR, Dispatch>( swapchain, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
10466 }
10467 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
10468 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10469
10470 #if defined( VK_USE_PLATFORM_XLIB_KHR )
10471 //=== VK_KHR_xlib_surface ===
10472
10473 // wrapper function for command vkCreateXlibSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateXlibSurfaceKHR.html
10474 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
10475 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createXlibSurfaceKHR( const XlibSurfaceCreateInfoKHR * pCreateInfo,
10476 const AllocationCallbacks * pAllocator,
10477 SurfaceKHR * pSurface,
10478 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
10479 {
10480 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
10481 return static_cast<Result>( d.vkCreateXlibSurfaceKHR( static_cast<VkInstance>( m_instance ),
10482 reinterpret_cast<const VkXlibSurfaceCreateInfoKHR *>( pCreateInfo ),
10483 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
10484 reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) );
10485 }
10486
10487 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10488 // wrapper function for command vkCreateXlibSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateXlibSurfaceKHR.html
10489 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
10490 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<SurfaceKHR>::type
10491 Instance::createXlibSurfaceKHR( const XlibSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
10492 {
10493 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
10494 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
10495 VULKAN_HPP_ASSERT( d.vkCreateXlibSurfaceKHR && "Function <vkCreateXlibSurfaceKHR> requires <VK_KHR_xlib_surface>" );
10496 # endif
10497
10498 SurfaceKHR surface;
10499 Result result = static_cast<Result>( d.vkCreateXlibSurfaceKHR( m_instance,
10500 reinterpret_cast<const VkXlibSurfaceCreateInfoKHR *>( &createInfo ),
10501 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
10502 reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
10503 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createXlibSurfaceKHR" );
10504
10505 return detail::createResultValueType( result, std::move( surface ) );
10506 }
10507
10508 # ifndef VULKAN_HPP_NO_SMART_HANDLE
10509 // wrapper function for command vkCreateXlibSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateXlibSurfaceKHR.html
10510 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
10511 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
10512 Instance::createXlibSurfaceKHRUnique( const XlibSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
10513 {
10514 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
10515 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
10516 VULKAN_HPP_ASSERT( d.vkCreateXlibSurfaceKHR && "Function <vkCreateXlibSurfaceKHR> requires <VK_KHR_xlib_surface>" );
10517 # endif
10518
10519 SurfaceKHR surface;
10520 Result result = static_cast<Result>( d.vkCreateXlibSurfaceKHR( m_instance,
10521 reinterpret_cast<const VkXlibSurfaceCreateInfoKHR *>( &createInfo ),
10522 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
10523 reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
10524 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createXlibSurfaceKHRUnique" );
10525
10526 return detail::createResultValueType( result,
10527 UniqueHandle<SurfaceKHR, Dispatch>( surface, detail::ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) );
10528 }
10529 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
10530 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10531
10532 // wrapper function for command vkGetPhysicalDeviceXlibPresentationSupportKHR, see
10533 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceXlibPresentationSupportKHR.html
10534 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
10535 VULKAN_HPP_INLINE Bool32
10536 PhysicalDevice::getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display * dpy, VisualID visualID, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
10537 {
10538 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
10539 return static_cast<Bool32>(
10540 d.vkGetPhysicalDeviceXlibPresentationSupportKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), queueFamilyIndex, dpy, visualID ) );
10541 }
10542
10543 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10544 // wrapper function for command vkGetPhysicalDeviceXlibPresentationSupportKHR, see
10545 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceXlibPresentationSupportKHR.html
10546 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
10547 VULKAN_HPP_INLINE Bool32
10548 PhysicalDevice::getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display & dpy, VisualID visualID, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
10549 {
10550 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
10551 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
10552 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceXlibPresentationSupportKHR &&
10553 "Function <vkGetPhysicalDeviceXlibPresentationSupportKHR> requires <VK_KHR_xlib_surface>" );
10554 # endif
10555
10556 VkBool32 result = d.vkGetPhysicalDeviceXlibPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &dpy, visualID );
10557
10558 return static_cast<Bool32>( result );
10559 }
10560 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10561 #endif /*VK_USE_PLATFORM_XLIB_KHR*/
10562
10563 #if defined( VK_USE_PLATFORM_XCB_KHR )
10564 //=== VK_KHR_xcb_surface ===
10565
10566 // wrapper function for command vkCreateXcbSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateXcbSurfaceKHR.html
10567 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
10568 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createXcbSurfaceKHR( const XcbSurfaceCreateInfoKHR * pCreateInfo,
10569 const AllocationCallbacks * pAllocator,
10570 SurfaceKHR * pSurface,
10571 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
10572 {
10573 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
10574 return static_cast<Result>( d.vkCreateXcbSurfaceKHR( static_cast<VkInstance>( m_instance ),
10575 reinterpret_cast<const VkXcbSurfaceCreateInfoKHR *>( pCreateInfo ),
10576 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
10577 reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) );
10578 }
10579
10580 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10581 // wrapper function for command vkCreateXcbSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateXcbSurfaceKHR.html
10582 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
10583 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<SurfaceKHR>::type
10584 Instance::createXcbSurfaceKHR( const XcbSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
10585 {
10586 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
10587 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
10588 VULKAN_HPP_ASSERT( d.vkCreateXcbSurfaceKHR && "Function <vkCreateXcbSurfaceKHR> requires <VK_KHR_xcb_surface>" );
10589 # endif
10590
10591 SurfaceKHR surface;
10592 Result result = static_cast<Result>( d.vkCreateXcbSurfaceKHR( m_instance,
10593 reinterpret_cast<const VkXcbSurfaceCreateInfoKHR *>( &createInfo ),
10594 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
10595 reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
10596 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createXcbSurfaceKHR" );
10597
10598 return detail::createResultValueType( result, std::move( surface ) );
10599 }
10600
10601 # ifndef VULKAN_HPP_NO_SMART_HANDLE
10602 // wrapper function for command vkCreateXcbSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateXcbSurfaceKHR.html
10603 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
10604 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
10605 Instance::createXcbSurfaceKHRUnique( const XcbSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
10606 {
10607 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
10608 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
10609 VULKAN_HPP_ASSERT( d.vkCreateXcbSurfaceKHR && "Function <vkCreateXcbSurfaceKHR> requires <VK_KHR_xcb_surface>" );
10610 # endif
10611
10612 SurfaceKHR surface;
10613 Result result = static_cast<Result>( d.vkCreateXcbSurfaceKHR( m_instance,
10614 reinterpret_cast<const VkXcbSurfaceCreateInfoKHR *>( &createInfo ),
10615 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
10616 reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
10617 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createXcbSurfaceKHRUnique" );
10618
10619 return detail::createResultValueType( result,
10620 UniqueHandle<SurfaceKHR, Dispatch>( surface, detail::ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) );
10621 }
10622 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
10623 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10624
10625 // wrapper function for command vkGetPhysicalDeviceXcbPresentationSupportKHR, see
10626 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceXcbPresentationSupportKHR.html
10627 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
10628 VULKAN_HPP_INLINE Bool32 PhysicalDevice::getXcbPresentationSupportKHR( uint32_t queueFamilyIndex,
10629 xcb_connection_t * connection,
10630 xcb_visualid_t visual_id,
10631 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
10632 {
10633 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
10634 return static_cast<Bool32>(
10635 d.vkGetPhysicalDeviceXcbPresentationSupportKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), queueFamilyIndex, connection, visual_id ) );
10636 }
10637
10638 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10639 // wrapper function for command vkGetPhysicalDeviceXcbPresentationSupportKHR, see
10640 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceXcbPresentationSupportKHR.html
10641 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
10642 VULKAN_HPP_INLINE Bool32 PhysicalDevice::getXcbPresentationSupportKHR( uint32_t queueFamilyIndex,
10643 xcb_connection_t & connection,
10644 xcb_visualid_t visual_id,
10645 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
10646 {
10647 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
10648 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
10649 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceXcbPresentationSupportKHR &&
10650 "Function <vkGetPhysicalDeviceXcbPresentationSupportKHR> requires <VK_KHR_xcb_surface>" );
10651 # endif
10652
10653 VkBool32 result = d.vkGetPhysicalDeviceXcbPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &connection, visual_id );
10654
10655 return static_cast<Bool32>( result );
10656 }
10657 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10658 #endif /*VK_USE_PLATFORM_XCB_KHR*/
10659
10660 #if defined( VK_USE_PLATFORM_WAYLAND_KHR )
10661 //=== VK_KHR_wayland_surface ===
10662
10663 // wrapper function for command vkCreateWaylandSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateWaylandSurfaceKHR.html
10664 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
10665 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createWaylandSurfaceKHR( const WaylandSurfaceCreateInfoKHR * pCreateInfo,
10666 const AllocationCallbacks * pAllocator,
10667 SurfaceKHR * pSurface,
10668 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
10669 {
10670 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
10671 return static_cast<Result>( d.vkCreateWaylandSurfaceKHR( static_cast<VkInstance>( m_instance ),
10672 reinterpret_cast<const VkWaylandSurfaceCreateInfoKHR *>( pCreateInfo ),
10673 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
10674 reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) );
10675 }
10676
10677 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10678 // wrapper function for command vkCreateWaylandSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateWaylandSurfaceKHR.html
10679 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
10680 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<SurfaceKHR>::type
10681 Instance::createWaylandSurfaceKHR( const WaylandSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
10682 {
10683 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
10684 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
10685 VULKAN_HPP_ASSERT( d.vkCreateWaylandSurfaceKHR && "Function <vkCreateWaylandSurfaceKHR> requires <VK_KHR_wayland_surface>" );
10686 # endif
10687
10688 SurfaceKHR surface;
10689 Result result = static_cast<Result>( d.vkCreateWaylandSurfaceKHR( m_instance,
10690 reinterpret_cast<const VkWaylandSurfaceCreateInfoKHR *>( &createInfo ),
10691 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
10692 reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
10693 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createWaylandSurfaceKHR" );
10694
10695 return detail::createResultValueType( result, std::move( surface ) );
10696 }
10697
10698 # ifndef VULKAN_HPP_NO_SMART_HANDLE
10699 // wrapper function for command vkCreateWaylandSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateWaylandSurfaceKHR.html
10700 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
10701 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type Instance::createWaylandSurfaceKHRUnique(
10702 const WaylandSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
10703 {
10704 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
10705 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
10706 VULKAN_HPP_ASSERT( d.vkCreateWaylandSurfaceKHR && "Function <vkCreateWaylandSurfaceKHR> requires <VK_KHR_wayland_surface>" );
10707 # endif
10708
10709 SurfaceKHR surface;
10710 Result result = static_cast<Result>( d.vkCreateWaylandSurfaceKHR( m_instance,
10711 reinterpret_cast<const VkWaylandSurfaceCreateInfoKHR *>( &createInfo ),
10712 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
10713 reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
10714 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createWaylandSurfaceKHRUnique" );
10715
10716 return detail::createResultValueType( result,
10717 UniqueHandle<SurfaceKHR, Dispatch>( surface, detail::ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) );
10718 }
10719 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
10720 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10721
10722 // wrapper function for command vkGetPhysicalDeviceWaylandPresentationSupportKHR, see
10723 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceWaylandPresentationSupportKHR.html
10724 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
10725 VULKAN_HPP_INLINE Bool32 PhysicalDevice::getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex,
10726 struct wl_display * display,
10727 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
10728 {
10729 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
10730 return static_cast<Bool32>(
10731 d.vkGetPhysicalDeviceWaylandPresentationSupportKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), queueFamilyIndex, display ) );
10732 }
10733
10734 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10735 // wrapper function for command vkGetPhysicalDeviceWaylandPresentationSupportKHR, see
10736 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceWaylandPresentationSupportKHR.html
10737 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
10738 VULKAN_HPP_INLINE Bool32 PhysicalDevice::getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex,
10739 struct wl_display & display,
10740 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
10741 {
10742 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
10743 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
10744 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceWaylandPresentationSupportKHR &&
10745 "Function <vkGetPhysicalDeviceWaylandPresentationSupportKHR> requires <VK_KHR_wayland_surface>" );
10746 # endif
10747
10748 VkBool32 result = d.vkGetPhysicalDeviceWaylandPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &display );
10749
10750 return static_cast<Bool32>( result );
10751 }
10752 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10753 #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
10754
10755 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
10756 //=== VK_KHR_android_surface ===
10757
10758 // wrapper function for command vkCreateAndroidSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAndroidSurfaceKHR.html
10759 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
10760 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createAndroidSurfaceKHR( const AndroidSurfaceCreateInfoKHR * pCreateInfo,
10761 const AllocationCallbacks * pAllocator,
10762 SurfaceKHR * pSurface,
10763 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
10764 {
10765 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
10766 return static_cast<Result>( d.vkCreateAndroidSurfaceKHR( static_cast<VkInstance>( m_instance ),
10767 reinterpret_cast<const VkAndroidSurfaceCreateInfoKHR *>( pCreateInfo ),
10768 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
10769 reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) );
10770 }
10771
10772 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10773 // wrapper function for command vkCreateAndroidSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAndroidSurfaceKHR.html
10774 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
10775 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<SurfaceKHR>::type
10776 Instance::createAndroidSurfaceKHR( const AndroidSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
10777 {
10778 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
10779 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
10780 VULKAN_HPP_ASSERT( d.vkCreateAndroidSurfaceKHR && "Function <vkCreateAndroidSurfaceKHR> requires <VK_KHR_android_surface>" );
10781 # endif
10782
10783 SurfaceKHR surface;
10784 Result result = static_cast<Result>( d.vkCreateAndroidSurfaceKHR( m_instance,
10785 reinterpret_cast<const VkAndroidSurfaceCreateInfoKHR *>( &createInfo ),
10786 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
10787 reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
10788 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createAndroidSurfaceKHR" );
10789
10790 return detail::createResultValueType( result, std::move( surface ) );
10791 }
10792
10793 # ifndef VULKAN_HPP_NO_SMART_HANDLE
10794 // wrapper function for command vkCreateAndroidSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAndroidSurfaceKHR.html
10795 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
10796 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type Instance::createAndroidSurfaceKHRUnique(
10797 const AndroidSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
10798 {
10799 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
10800 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
10801 VULKAN_HPP_ASSERT( d.vkCreateAndroidSurfaceKHR && "Function <vkCreateAndroidSurfaceKHR> requires <VK_KHR_android_surface>" );
10802 # endif
10803
10804 SurfaceKHR surface;
10805 Result result = static_cast<Result>( d.vkCreateAndroidSurfaceKHR( m_instance,
10806 reinterpret_cast<const VkAndroidSurfaceCreateInfoKHR *>( &createInfo ),
10807 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
10808 reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
10809 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createAndroidSurfaceKHRUnique" );
10810
10811 return detail::createResultValueType( result,
10812 UniqueHandle<SurfaceKHR, Dispatch>( surface, detail::ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) );
10813 }
10814 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
10815 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10816 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
10817
10818 #if defined( VK_USE_PLATFORM_WIN32_KHR )
10819 //=== VK_KHR_win32_surface ===
10820
10821 // wrapper function for command vkCreateWin32SurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateWin32SurfaceKHR.html
10822 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
10823 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createWin32SurfaceKHR( const Win32SurfaceCreateInfoKHR * pCreateInfo,
10824 const AllocationCallbacks * pAllocator,
10825 SurfaceKHR * pSurface,
10826 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
10827 {
10828 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
10829 return static_cast<Result>( d.vkCreateWin32SurfaceKHR( static_cast<VkInstance>( m_instance ),
10830 reinterpret_cast<const VkWin32SurfaceCreateInfoKHR *>( pCreateInfo ),
10831 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
10832 reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) );
10833 }
10834
10835 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10836 // wrapper function for command vkCreateWin32SurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateWin32SurfaceKHR.html
10837 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
10838 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<SurfaceKHR>::type
10839 Instance::createWin32SurfaceKHR( const Win32SurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
10840 {
10841 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
10842 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
10843 VULKAN_HPP_ASSERT( d.vkCreateWin32SurfaceKHR && "Function <vkCreateWin32SurfaceKHR> requires <VK_KHR_win32_surface>" );
10844 # endif
10845
10846 SurfaceKHR surface;
10847 Result result = static_cast<Result>( d.vkCreateWin32SurfaceKHR( m_instance,
10848 reinterpret_cast<const VkWin32SurfaceCreateInfoKHR *>( &createInfo ),
10849 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
10850 reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
10851 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createWin32SurfaceKHR" );
10852
10853 return detail::createResultValueType( result, std::move( surface ) );
10854 }
10855
10856 # ifndef VULKAN_HPP_NO_SMART_HANDLE
10857 // wrapper function for command vkCreateWin32SurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateWin32SurfaceKHR.html
10858 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
10859 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type Instance::createWin32SurfaceKHRUnique(
10860 const Win32SurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
10861 {
10862 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
10863 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
10864 VULKAN_HPP_ASSERT( d.vkCreateWin32SurfaceKHR && "Function <vkCreateWin32SurfaceKHR> requires <VK_KHR_win32_surface>" );
10865 # endif
10866
10867 SurfaceKHR surface;
10868 Result result = static_cast<Result>( d.vkCreateWin32SurfaceKHR( m_instance,
10869 reinterpret_cast<const VkWin32SurfaceCreateInfoKHR *>( &createInfo ),
10870 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
10871 reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
10872 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createWin32SurfaceKHRUnique" );
10873
10874 return detail::createResultValueType( result,
10875 UniqueHandle<SurfaceKHR, Dispatch>( surface, detail::ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) );
10876 }
10877 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
10878 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10879
10880 // wrapper function for command vkGetPhysicalDeviceWin32PresentationSupportKHR, see
10881 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceWin32PresentationSupportKHR.html
10882 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
10883 VULKAN_HPP_INLINE Bool32 PhysicalDevice::getWin32PresentationSupportKHR( uint32_t queueFamilyIndex, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
10884 {
10885 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
10886 return static_cast<Bool32>( d.vkGetPhysicalDeviceWin32PresentationSupportKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), queueFamilyIndex ) );
10887 }
10888 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
10889
10890 //=== VK_EXT_debug_report ===
10891
10892 // wrapper function for command vkCreateDebugReportCallbackEXT, see
10893 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDebugReportCallbackEXT.html
10894 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
10895 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createDebugReportCallbackEXT( const DebugReportCallbackCreateInfoEXT * pCreateInfo,
10896 const AllocationCallbacks * pAllocator,
10897 DebugReportCallbackEXT * pCallback,
10898 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
10899 {
10900 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
10901 return static_cast<Result>( d.vkCreateDebugReportCallbackEXT( static_cast<VkInstance>( m_instance ),
10902 reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT *>( pCreateInfo ),
10903 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
10904 reinterpret_cast<VkDebugReportCallbackEXT *>( pCallback ) ) );
10905 }
10906
10907 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10908 // wrapper function for command vkCreateDebugReportCallbackEXT, see
10909 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDebugReportCallbackEXT.html
10910 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
10911 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<DebugReportCallbackEXT>::type Instance::createDebugReportCallbackEXT(
10912 const DebugReportCallbackCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
10913 {
10914 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
10915 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
10916 VULKAN_HPP_ASSERT( d.vkCreateDebugReportCallbackEXT && "Function <vkCreateDebugReportCallbackEXT> requires <VK_EXT_debug_report>" );
10917 # endif
10918
10919 DebugReportCallbackEXT callback;
10920 Result result = static_cast<Result>( d.vkCreateDebugReportCallbackEXT( m_instance,
10921 reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT *>( &createInfo ),
10922 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
10923 reinterpret_cast<VkDebugReportCallbackEXT *>( &callback ) ) );
10924 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDebugReportCallbackEXT" );
10925
10926 return detail::createResultValueType( result, std::move( callback ) );
10927 }
10928
10929 # ifndef VULKAN_HPP_NO_SMART_HANDLE
10930 // wrapper function for command vkCreateDebugReportCallbackEXT, see
10931 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDebugReportCallbackEXT.html
10932 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
10933 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<DebugReportCallbackEXT, Dispatch>>::type
10934 Instance::createDebugReportCallbackEXTUnique( const DebugReportCallbackCreateInfoEXT & createInfo,
10935 Optional<const AllocationCallbacks> allocator,
10936 Dispatch const & d ) const
10937 {
10938 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
10939 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
10940 VULKAN_HPP_ASSERT( d.vkCreateDebugReportCallbackEXT && "Function <vkCreateDebugReportCallbackEXT> requires <VK_EXT_debug_report>" );
10941 # endif
10942
10943 DebugReportCallbackEXT callback;
10944 Result result = static_cast<Result>( d.vkCreateDebugReportCallbackEXT( m_instance,
10945 reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT *>( &createInfo ),
10946 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
10947 reinterpret_cast<VkDebugReportCallbackEXT *>( &callback ) ) );
10948 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDebugReportCallbackEXTUnique" );
10949
10950 return detail::createResultValueType(
10951 result, UniqueHandle<DebugReportCallbackEXT, Dispatch>( callback, detail::ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) );
10952 }
10953 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
10954 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10955
10956 // wrapper function for command vkDestroyDebugReportCallbackEXT, see
10957 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDebugReportCallbackEXT.html
10958 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
10959 VULKAN_HPP_INLINE void Instance::destroyDebugReportCallbackEXT( DebugReportCallbackEXT callback,
10960 const AllocationCallbacks * pAllocator,
10961 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
10962 {
10963 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
10964 d.vkDestroyDebugReportCallbackEXT(
10965 static_cast<VkInstance>( m_instance ), static_cast<VkDebugReportCallbackEXT>( callback ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
10966 }
10967
10968 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10969 // wrapper function for command vkDestroyDebugReportCallbackEXT, see
10970 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDebugReportCallbackEXT.html
10971 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
10972 VULKAN_HPP_INLINE void Instance::destroyDebugReportCallbackEXT( DebugReportCallbackEXT callback,
10973 Optional<const AllocationCallbacks> allocator,
10974 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
10975 {
10976 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
10977 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
10978 VULKAN_HPP_ASSERT( d.vkDestroyDebugReportCallbackEXT && "Function <vkDestroyDebugReportCallbackEXT> requires <VK_EXT_debug_report>" );
10979 # endif
10980
10981 d.vkDestroyDebugReportCallbackEXT(
10982 m_instance, static_cast<VkDebugReportCallbackEXT>( callback ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
10983 }
10984 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10985
10986 // wrapper function for command vkDestroyDebugReportCallbackEXT, see
10987 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDebugReportCallbackEXT.html
10988 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
10989 VULKAN_HPP_INLINE void
10990 Instance::destroy( DebugReportCallbackEXT callback, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
10991 {
10992 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
10993 d.vkDestroyDebugReportCallbackEXT(
10994 static_cast<VkInstance>( m_instance ), static_cast<VkDebugReportCallbackEXT>( callback ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
10995 }
10996
10997 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10998 // wrapper function for command vkDestroyDebugReportCallbackEXT, see
10999 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDebugReportCallbackEXT.html
11000 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
11001 VULKAN_HPP_INLINE void
11002 Instance::destroy( DebugReportCallbackEXT callback, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
11003 {
11004 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
11005 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
11006 VULKAN_HPP_ASSERT( d.vkDestroyDebugReportCallbackEXT && "Function <vkDestroyDebugReportCallbackEXT> requires <VK_EXT_debug_report>" );
11007 # endif
11008
11009 d.vkDestroyDebugReportCallbackEXT(
11010 m_instance, static_cast<VkDebugReportCallbackEXT>( callback ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
11011 }
11012 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11013
11014 // wrapper function for command vkDebugReportMessageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDebugReportMessageEXT.html
11015 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
11016 VULKAN_HPP_INLINE void Instance::debugReportMessageEXT( DebugReportFlagsEXT flags,
11017 DebugReportObjectTypeEXT objectType_,
11018 uint64_t object,
11019 size_t location,
11020 int32_t messageCode,
11021 const char * pLayerPrefix,
11022 const char * pMessage,
11023 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
11024 {
11025 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
11026 d.vkDebugReportMessageEXT( static_cast<VkInstance>( m_instance ),
11027 static_cast<VkDebugReportFlagsEXT>( flags ),
11028 static_cast<VkDebugReportObjectTypeEXT>( objectType_ ),
11029 object,
11030 location,
11031 messageCode,
11032 pLayerPrefix,
11033 pMessage );
11034 }
11035
11036 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11037 // wrapper function for command vkDebugReportMessageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDebugReportMessageEXT.html
11038 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
11039 VULKAN_HPP_INLINE void Instance::debugReportMessageEXT( DebugReportFlagsEXT flags,
11040 DebugReportObjectTypeEXT objectType_,
11041 uint64_t object,
11042 size_t location,
11043 int32_t messageCode,
11044 const std::string & layerPrefix,
11045 const std::string & message,
11046 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
11047 {
11048 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
11049 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
11050 VULKAN_HPP_ASSERT( d.vkDebugReportMessageEXT && "Function <vkDebugReportMessageEXT> requires <VK_EXT_debug_report>" );
11051 # endif
11052
11053 d.vkDebugReportMessageEXT( m_instance,
11054 static_cast<VkDebugReportFlagsEXT>( flags ),
11055 static_cast<VkDebugReportObjectTypeEXT>( objectType_ ),
11056 object,
11057 location,
11058 messageCode,
11059 layerPrefix.c_str(),
11060 message.c_str() );
11061 }
11062 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11063
11064 //=== VK_EXT_debug_marker ===
11065
11066 // wrapper function for command vkDebugMarkerSetObjectTagEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDebugMarkerSetObjectTagEXT.html
11067 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
11068 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::debugMarkerSetObjectTagEXT( const DebugMarkerObjectTagInfoEXT * pTagInfo,
11069 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
11070 {
11071 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
11072 return static_cast<Result>(
11073 d.vkDebugMarkerSetObjectTagEXT( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkDebugMarkerObjectTagInfoEXT *>( pTagInfo ) ) );
11074 }
11075
11076 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11077 // wrapper function for command vkDebugMarkerSetObjectTagEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDebugMarkerSetObjectTagEXT.html
11078 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
11079 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
11080 Device::debugMarkerSetObjectTagEXT( const DebugMarkerObjectTagInfoEXT & tagInfo, Dispatch const & d ) const
11081 {
11082 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
11083 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
11084 VULKAN_HPP_ASSERT( d.vkDebugMarkerSetObjectTagEXT && "Function <vkDebugMarkerSetObjectTagEXT> requires <VK_EXT_debug_marker>" );
11085 # endif
11086
11087 Result result = static_cast<Result>( d.vkDebugMarkerSetObjectTagEXT( m_device, reinterpret_cast<const VkDebugMarkerObjectTagInfoEXT *>( &tagInfo ) ) );
11088 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::debugMarkerSetObjectTagEXT" );
11089
11090 return detail::createResultValueType( result );
11091 }
11092 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11093
11094 // wrapper function for command vkDebugMarkerSetObjectNameEXT, see
11095 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDebugMarkerSetObjectNameEXT.html
11096 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
11097 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::debugMarkerSetObjectNameEXT( const DebugMarkerObjectNameInfoEXT * pNameInfo,
11098 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
11099 {
11100 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
11101 return static_cast<Result>(
11102 d.vkDebugMarkerSetObjectNameEXT( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkDebugMarkerObjectNameInfoEXT *>( pNameInfo ) ) );
11103 }
11104
11105 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11106 // wrapper function for command vkDebugMarkerSetObjectNameEXT, see
11107 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDebugMarkerSetObjectNameEXT.html
11108 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
11109 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
11110 Device::debugMarkerSetObjectNameEXT( const DebugMarkerObjectNameInfoEXT & nameInfo, Dispatch const & d ) const
11111 {
11112 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
11113 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
11114 VULKAN_HPP_ASSERT( d.vkDebugMarkerSetObjectNameEXT && "Function <vkDebugMarkerSetObjectNameEXT> requires <VK_EXT_debug_marker>" );
11115 # endif
11116
11117 Result result = static_cast<Result>( d.vkDebugMarkerSetObjectNameEXT( m_device, reinterpret_cast<const VkDebugMarkerObjectNameInfoEXT *>( &nameInfo ) ) );
11118 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::debugMarkerSetObjectNameEXT" );
11119
11120 return detail::createResultValueType( result );
11121 }
11122 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11123
11124 // wrapper function for command vkCmdDebugMarkerBeginEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDebugMarkerBeginEXT.html
11125 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
11126 VULKAN_HPP_INLINE void CommandBuffer::debugMarkerBeginEXT( const DebugMarkerMarkerInfoEXT * pMarkerInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
11127 {
11128 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
11129 d.vkCmdDebugMarkerBeginEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkDebugMarkerMarkerInfoEXT *>( pMarkerInfo ) );
11130 }
11131
11132 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11133 // wrapper function for command vkCmdDebugMarkerBeginEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDebugMarkerBeginEXT.html
11134 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
11135 VULKAN_HPP_INLINE void CommandBuffer::debugMarkerBeginEXT( const DebugMarkerMarkerInfoEXT & markerInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
11136 {
11137 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
11138 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
11139 VULKAN_HPP_ASSERT( d.vkCmdDebugMarkerBeginEXT && "Function <vkCmdDebugMarkerBeginEXT> requires <VK_EXT_debug_marker>" );
11140 # endif
11141
11142 d.vkCmdDebugMarkerBeginEXT( m_commandBuffer, reinterpret_cast<const VkDebugMarkerMarkerInfoEXT *>( &markerInfo ) );
11143 }
11144 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11145
11146 // wrapper function for command vkCmdDebugMarkerEndEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDebugMarkerEndEXT.html
11147 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
11148 VULKAN_HPP_INLINE void CommandBuffer::debugMarkerEndEXT( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
11149 {
11150 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
11151 d.vkCmdDebugMarkerEndEXT( static_cast<VkCommandBuffer>( m_commandBuffer ) );
11152 }
11153
11154 // wrapper function for command vkCmdDebugMarkerInsertEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDebugMarkerInsertEXT.html
11155 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
11156 VULKAN_HPP_INLINE void CommandBuffer::debugMarkerInsertEXT( const DebugMarkerMarkerInfoEXT * pMarkerInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
11157 {
11158 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
11159 d.vkCmdDebugMarkerInsertEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkDebugMarkerMarkerInfoEXT *>( pMarkerInfo ) );
11160 }
11161
11162 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11163 // wrapper function for command vkCmdDebugMarkerInsertEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDebugMarkerInsertEXT.html
11164 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
11165 VULKAN_HPP_INLINE void CommandBuffer::debugMarkerInsertEXT( const DebugMarkerMarkerInfoEXT & markerInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
11166 {
11167 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
11168 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
11169 VULKAN_HPP_ASSERT( d.vkCmdDebugMarkerInsertEXT && "Function <vkCmdDebugMarkerInsertEXT> requires <VK_EXT_debug_marker>" );
11170 # endif
11171
11172 d.vkCmdDebugMarkerInsertEXT( m_commandBuffer, reinterpret_cast<const VkDebugMarkerMarkerInfoEXT *>( &markerInfo ) );
11173 }
11174 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11175
11176 //=== VK_KHR_video_queue ===
11177
11178 // wrapper function for command vkGetPhysicalDeviceVideoCapabilitiesKHR, see
11179 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoCapabilitiesKHR.html
11180 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
11181 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getVideoCapabilitiesKHR( const VideoProfileInfoKHR * pVideoProfile,
11182 VideoCapabilitiesKHR * pCapabilities,
11183 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
11184 {
11185 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
11186 return static_cast<Result>( d.vkGetPhysicalDeviceVideoCapabilitiesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
11187 reinterpret_cast<const VkVideoProfileInfoKHR *>( pVideoProfile ),
11188 reinterpret_cast<VkVideoCapabilitiesKHR *>( pCapabilities ) ) );
11189 }
11190
11191 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11192 // wrapper function for command vkGetPhysicalDeviceVideoCapabilitiesKHR, see
11193 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoCapabilitiesKHR.html
11194 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
11195 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VideoCapabilitiesKHR>::type
11196 PhysicalDevice::getVideoCapabilitiesKHR( const VideoProfileInfoKHR & videoProfile, Dispatch const & d ) const
11197 {
11198 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
11199 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
11200 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceVideoCapabilitiesKHR && "Function <vkGetPhysicalDeviceVideoCapabilitiesKHR> requires <VK_KHR_video_queue>" );
11201 # endif
11202
11203 VideoCapabilitiesKHR capabilities;
11204 Result result = static_cast<Result>( d.vkGetPhysicalDeviceVideoCapabilitiesKHR(
11205 m_physicalDevice, reinterpret_cast<const VkVideoProfileInfoKHR *>( &videoProfile ), reinterpret_cast<VkVideoCapabilitiesKHR *>( &capabilities ) ) );
11206 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoCapabilitiesKHR" );
11207
11208 return detail::createResultValueType( result, std::move( capabilities ) );
11209 }
11210
11211 // wrapper function for command vkGetPhysicalDeviceVideoCapabilitiesKHR, see
11212 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoCapabilitiesKHR.html
11213 template <typename X, typename Y, typename... Z, typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
11214 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<StructureChain<X, Y, Z...>>::type
11215 PhysicalDevice::getVideoCapabilitiesKHR( const VideoProfileInfoKHR & videoProfile, Dispatch const & d ) const
11216 {
11217 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
11218 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
11219 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceVideoCapabilitiesKHR && "Function <vkGetPhysicalDeviceVideoCapabilitiesKHR> requires <VK_KHR_video_queue>" );
11220 # endif
11221
11222 StructureChain<X, Y, Z...> structureChain;
11223 VideoCapabilitiesKHR & capabilities = structureChain.template get<VideoCapabilitiesKHR>();
11224 Result result = static_cast<Result>( d.vkGetPhysicalDeviceVideoCapabilitiesKHR(
11225 m_physicalDevice, reinterpret_cast<const VkVideoProfileInfoKHR *>( &videoProfile ), reinterpret_cast<VkVideoCapabilitiesKHR *>( &capabilities ) ) );
11226 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoCapabilitiesKHR" );
11227
11228 return detail::createResultValueType( result, std::move( structureChain ) );
11229 }
11230 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11231
11232 // wrapper function for command vkGetPhysicalDeviceVideoFormatPropertiesKHR, see
11233 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoFormatPropertiesKHR.html
11234 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
11235 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getVideoFormatPropertiesKHR( const PhysicalDeviceVideoFormatInfoKHR * pVideoFormatInfo,
11236 uint32_t * pVideoFormatPropertyCount,
11237 VideoFormatPropertiesKHR * pVideoFormatProperties,
11238 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
11239 {
11240 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
11241 return static_cast<Result>( d.vkGetPhysicalDeviceVideoFormatPropertiesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
11242 reinterpret_cast<const VkPhysicalDeviceVideoFormatInfoKHR *>( pVideoFormatInfo ),
11243 pVideoFormatPropertyCount,
11244 reinterpret_cast<VkVideoFormatPropertiesKHR *>( pVideoFormatProperties ) ) );
11245 }
11246
11247 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11248 // wrapper function for command vkGetPhysicalDeviceVideoFormatPropertiesKHR, see
11249 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoFormatPropertiesKHR.html
11250 template <typename VideoFormatPropertiesKHRAllocator,
11251 typename Dispatch,
11252 typename std::enable_if<std::is_same<typename VideoFormatPropertiesKHRAllocator::value_type, VideoFormatPropertiesKHR>::value, int>::type,
11253 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
11254 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VideoFormatPropertiesKHR, VideoFormatPropertiesKHRAllocator>>::type
11255 PhysicalDevice::getVideoFormatPropertiesKHR( const PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo, Dispatch const & d ) const
11256 {
11257 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
11258 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
11259 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceVideoFormatPropertiesKHR &&
11260 "Function <vkGetPhysicalDeviceVideoFormatPropertiesKHR> requires <VK_KHR_video_queue>" );
11261 # endif
11262
11263 std::vector<VideoFormatPropertiesKHR, VideoFormatPropertiesKHRAllocator> videoFormatProperties;
11264 uint32_t videoFormatPropertyCount;
11265 Result result;
11266 do
11267 {
11268 result = static_cast<Result>( d.vkGetPhysicalDeviceVideoFormatPropertiesKHR(
11269 m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceVideoFormatInfoKHR *>( &videoFormatInfo ), &videoFormatPropertyCount, nullptr ) );
11270 if ( ( result == Result::eSuccess ) && videoFormatPropertyCount )
11271 {
11272 videoFormatProperties.resize( videoFormatPropertyCount );
11273 result = static_cast<Result>(
11274 d.vkGetPhysicalDeviceVideoFormatPropertiesKHR( m_physicalDevice,
11275 reinterpret_cast<const VkPhysicalDeviceVideoFormatInfoKHR *>( &videoFormatInfo ),
11276 &videoFormatPropertyCount,
11277 reinterpret_cast<VkVideoFormatPropertiesKHR *>( videoFormatProperties.data() ) ) );
11278 }
11279 } while ( result == Result::eIncomplete );
11280 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoFormatPropertiesKHR" );
11281 VULKAN_HPP_ASSERT( videoFormatPropertyCount <= videoFormatProperties.size() );
11282 if ( videoFormatPropertyCount < videoFormatProperties.size() )
11283 {
11284 videoFormatProperties.resize( videoFormatPropertyCount );
11285 }
11286 return detail::createResultValueType( result, std::move( videoFormatProperties ) );
11287 }
11288
11289 // wrapper function for command vkGetPhysicalDeviceVideoFormatPropertiesKHR, see
11290 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoFormatPropertiesKHR.html
11291 template <typename VideoFormatPropertiesKHRAllocator,
11292 typename Dispatch,
11293 typename std::enable_if<std::is_same<typename VideoFormatPropertiesKHRAllocator::value_type, VideoFormatPropertiesKHR>::value, int>::type,
11294 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
11295 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VideoFormatPropertiesKHR, VideoFormatPropertiesKHRAllocator>>::type
11296 PhysicalDevice::getVideoFormatPropertiesKHR( const PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo,
11297 VideoFormatPropertiesKHRAllocator & videoFormatPropertiesKHRAllocator,
11298 Dispatch const & d ) const
11299 {
11300 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
11301 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
11302 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceVideoFormatPropertiesKHR &&
11303 "Function <vkGetPhysicalDeviceVideoFormatPropertiesKHR> requires <VK_KHR_video_queue>" );
11304 # endif
11305
11306 std::vector<VideoFormatPropertiesKHR, VideoFormatPropertiesKHRAllocator> videoFormatProperties( videoFormatPropertiesKHRAllocator );
11307 uint32_t videoFormatPropertyCount;
11308 Result result;
11309 do
11310 {
11311 result = static_cast<Result>( d.vkGetPhysicalDeviceVideoFormatPropertiesKHR(
11312 m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceVideoFormatInfoKHR *>( &videoFormatInfo ), &videoFormatPropertyCount, nullptr ) );
11313 if ( ( result == Result::eSuccess ) && videoFormatPropertyCount )
11314 {
11315 videoFormatProperties.resize( videoFormatPropertyCount );
11316 result = static_cast<Result>(
11317 d.vkGetPhysicalDeviceVideoFormatPropertiesKHR( m_physicalDevice,
11318 reinterpret_cast<const VkPhysicalDeviceVideoFormatInfoKHR *>( &videoFormatInfo ),
11319 &videoFormatPropertyCount,
11320 reinterpret_cast<VkVideoFormatPropertiesKHR *>( videoFormatProperties.data() ) ) );
11321 }
11322 } while ( result == Result::eIncomplete );
11323 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoFormatPropertiesKHR" );
11324 VULKAN_HPP_ASSERT( videoFormatPropertyCount <= videoFormatProperties.size() );
11325 if ( videoFormatPropertyCount < videoFormatProperties.size() )
11326 {
11327 videoFormatProperties.resize( videoFormatPropertyCount );
11328 }
11329 return detail::createResultValueType( result, std::move( videoFormatProperties ) );
11330 }
11331
11332 // wrapper function for command vkGetPhysicalDeviceVideoFormatPropertiesKHR, see
11333 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoFormatPropertiesKHR.html
11334 template <typename StructureChain,
11335 typename StructureChainAllocator,
11336 typename Dispatch,
11337 typename std::enable_if<std::is_same<typename StructureChainAllocator::value_type, StructureChain>::value, int>::type,
11338 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
11339 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<StructureChain, StructureChainAllocator>>::type
11340 PhysicalDevice::getVideoFormatPropertiesKHR( const PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo, Dispatch const & d ) const
11341 {
11342 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
11343 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
11344 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceVideoFormatPropertiesKHR &&
11345 "Function <vkGetPhysicalDeviceVideoFormatPropertiesKHR> requires <VK_KHR_video_queue>" );
11346 # endif
11347
11348 std::vector<StructureChain, StructureChainAllocator> structureChains;
11349 std::vector<VideoFormatPropertiesKHR> videoFormatProperties;
11350 uint32_t videoFormatPropertyCount;
11351 Result result;
11352 do
11353 {
11354 result = static_cast<Result>( d.vkGetPhysicalDeviceVideoFormatPropertiesKHR(
11355 m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceVideoFormatInfoKHR *>( &videoFormatInfo ), &videoFormatPropertyCount, nullptr ) );
11356 if ( ( result == Result::eSuccess ) && videoFormatPropertyCount )
11357 {
11358 structureChains.resize( videoFormatPropertyCount );
11359 videoFormatProperties.resize( videoFormatPropertyCount );
11360 for ( uint32_t i = 0; i < videoFormatPropertyCount; i++ )
11361 {
11362 videoFormatProperties[i].pNext = structureChains[i].template get<VideoFormatPropertiesKHR>().pNext;
11363 }
11364 result = static_cast<Result>(
11365 d.vkGetPhysicalDeviceVideoFormatPropertiesKHR( m_physicalDevice,
11366 reinterpret_cast<const VkPhysicalDeviceVideoFormatInfoKHR *>( &videoFormatInfo ),
11367 &videoFormatPropertyCount,
11368 reinterpret_cast<VkVideoFormatPropertiesKHR *>( videoFormatProperties.data() ) ) );
11369 }
11370 } while ( result == Result::eIncomplete );
11371 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoFormatPropertiesKHR" );
11372 VULKAN_HPP_ASSERT( videoFormatPropertyCount <= videoFormatProperties.size() );
11373 if ( videoFormatPropertyCount < videoFormatProperties.size() )
11374 {
11375 structureChains.resize( videoFormatPropertyCount );
11376 }
11377 for ( uint32_t i = 0; i < videoFormatPropertyCount; i++ )
11378 {
11379 structureChains[i].template get<VideoFormatPropertiesKHR>() = videoFormatProperties[i];
11380 }
11381 return detail::createResultValueType( result, std::move( structureChains ) );
11382 }
11383
11384 // wrapper function for command vkGetPhysicalDeviceVideoFormatPropertiesKHR, see
11385 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoFormatPropertiesKHR.html
11386 template <typename StructureChain,
11387 typename StructureChainAllocator,
11388 typename Dispatch,
11389 typename std::enable_if<std::is_same<typename StructureChainAllocator::value_type, StructureChain>::value, int>::type,
11390 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
11391 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<StructureChain, StructureChainAllocator>>::type
11392 PhysicalDevice::getVideoFormatPropertiesKHR( const PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo,
11393 StructureChainAllocator & structureChainAllocator,
11394 Dispatch const & d ) const
11395 {
11396 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
11397 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
11398 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceVideoFormatPropertiesKHR &&
11399 "Function <vkGetPhysicalDeviceVideoFormatPropertiesKHR> requires <VK_KHR_video_queue>" );
11400 # endif
11401
11402 std::vector<StructureChain, StructureChainAllocator> structureChains( structureChainAllocator );
11403 std::vector<VideoFormatPropertiesKHR> videoFormatProperties;
11404 uint32_t videoFormatPropertyCount;
11405 Result result;
11406 do
11407 {
11408 result = static_cast<Result>( d.vkGetPhysicalDeviceVideoFormatPropertiesKHR(
11409 m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceVideoFormatInfoKHR *>( &videoFormatInfo ), &videoFormatPropertyCount, nullptr ) );
11410 if ( ( result == Result::eSuccess ) && videoFormatPropertyCount )
11411 {
11412 structureChains.resize( videoFormatPropertyCount );
11413 videoFormatProperties.resize( videoFormatPropertyCount );
11414 for ( uint32_t i = 0; i < videoFormatPropertyCount; i++ )
11415 {
11416 videoFormatProperties[i].pNext = structureChains[i].template get<VideoFormatPropertiesKHR>().pNext;
11417 }
11418 result = static_cast<Result>(
11419 d.vkGetPhysicalDeviceVideoFormatPropertiesKHR( m_physicalDevice,
11420 reinterpret_cast<const VkPhysicalDeviceVideoFormatInfoKHR *>( &videoFormatInfo ),
11421 &videoFormatPropertyCount,
11422 reinterpret_cast<VkVideoFormatPropertiesKHR *>( videoFormatProperties.data() ) ) );
11423 }
11424 } while ( result == Result::eIncomplete );
11425 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoFormatPropertiesKHR" );
11426 VULKAN_HPP_ASSERT( videoFormatPropertyCount <= videoFormatProperties.size() );
11427 if ( videoFormatPropertyCount < videoFormatProperties.size() )
11428 {
11429 structureChains.resize( videoFormatPropertyCount );
11430 }
11431 for ( uint32_t i = 0; i < videoFormatPropertyCount; i++ )
11432 {
11433 structureChains[i].template get<VideoFormatPropertiesKHR>() = videoFormatProperties[i];
11434 }
11435 return detail::createResultValueType( result, std::move( structureChains ) );
11436 }
11437 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11438
11439 // wrapper function for command vkCreateVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateVideoSessionKHR.html
11440 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
11441 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createVideoSessionKHR( const VideoSessionCreateInfoKHR * pCreateInfo,
11442 const AllocationCallbacks * pAllocator,
11443 VideoSessionKHR * pVideoSession,
11444 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
11445 {
11446 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
11447 return static_cast<Result>( d.vkCreateVideoSessionKHR( static_cast<VkDevice>( m_device ),
11448 reinterpret_cast<const VkVideoSessionCreateInfoKHR *>( pCreateInfo ),
11449 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
11450 reinterpret_cast<VkVideoSessionKHR *>( pVideoSession ) ) );
11451 }
11452
11453 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11454 // wrapper function for command vkCreateVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateVideoSessionKHR.html
11455 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
11456 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VideoSessionKHR>::type
11457 Device::createVideoSessionKHR( const VideoSessionCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
11458 {
11459 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
11460 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
11461 VULKAN_HPP_ASSERT( d.vkCreateVideoSessionKHR && "Function <vkCreateVideoSessionKHR> requires <VK_KHR_video_queue>" );
11462 # endif
11463
11464 VideoSessionKHR videoSession;
11465 Result result = static_cast<Result>( d.vkCreateVideoSessionKHR( m_device,
11466 reinterpret_cast<const VkVideoSessionCreateInfoKHR *>( &createInfo ),
11467 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
11468 reinterpret_cast<VkVideoSessionKHR *>( &videoSession ) ) );
11469 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createVideoSessionKHR" );
11470
11471 return detail::createResultValueType( result, std::move( videoSession ) );
11472 }
11473
11474 # ifndef VULKAN_HPP_NO_SMART_HANDLE
11475 // wrapper function for command vkCreateVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateVideoSessionKHR.html
11476 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
11477 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VideoSessionKHR, Dispatch>>::type
11478 Device::createVideoSessionKHRUnique( const VideoSessionCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
11479 {
11480 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
11481 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
11482 VULKAN_HPP_ASSERT( d.vkCreateVideoSessionKHR && "Function <vkCreateVideoSessionKHR> requires <VK_KHR_video_queue>" );
11483 # endif
11484
11485 VideoSessionKHR videoSession;
11486 Result result = static_cast<Result>( d.vkCreateVideoSessionKHR( m_device,
11487 reinterpret_cast<const VkVideoSessionCreateInfoKHR *>( &createInfo ),
11488 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
11489 reinterpret_cast<VkVideoSessionKHR *>( &videoSession ) ) );
11490 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createVideoSessionKHRUnique" );
11491
11492 return detail::createResultValueType(
11493 result, UniqueHandle<VideoSessionKHR, Dispatch>( videoSession, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
11494 }
11495 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
11496 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11497
11498 // wrapper function for command vkDestroyVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyVideoSessionKHR.html
11499 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
11500 VULKAN_HPP_INLINE void
11501 Device::destroyVideoSessionKHR( VideoSessionKHR videoSession, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
11502 {
11503 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
11504 d.vkDestroyVideoSessionKHR(
11505 static_cast<VkDevice>( m_device ), static_cast<VkVideoSessionKHR>( videoSession ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
11506 }
11507
11508 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11509 // wrapper function for command vkDestroyVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyVideoSessionKHR.html
11510 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
11511 VULKAN_HPP_INLINE void
11512 Device::destroyVideoSessionKHR( VideoSessionKHR videoSession, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
11513 {
11514 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
11515 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
11516 VULKAN_HPP_ASSERT( d.vkDestroyVideoSessionKHR && "Function <vkDestroyVideoSessionKHR> requires <VK_KHR_video_queue>" );
11517 # endif
11518
11519 d.vkDestroyVideoSessionKHR( m_device, static_cast<VkVideoSessionKHR>( videoSession ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
11520 }
11521 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11522
11523 // wrapper function for command vkDestroyVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyVideoSessionKHR.html
11524 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
11525 VULKAN_HPP_INLINE void Device::destroy( VideoSessionKHR videoSession, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
11526 {
11527 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
11528 d.vkDestroyVideoSessionKHR(
11529 static_cast<VkDevice>( m_device ), static_cast<VkVideoSessionKHR>( videoSession ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
11530 }
11531
11532 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11533 // wrapper function for command vkDestroyVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyVideoSessionKHR.html
11534 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
11535 VULKAN_HPP_INLINE void
11536 Device::destroy( VideoSessionKHR videoSession, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
11537 {
11538 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
11539 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
11540 VULKAN_HPP_ASSERT( d.vkDestroyVideoSessionKHR && "Function <vkDestroyVideoSessionKHR> requires <VK_KHR_video_queue>" );
11541 # endif
11542
11543 d.vkDestroyVideoSessionKHR( m_device, static_cast<VkVideoSessionKHR>( videoSession ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
11544 }
11545 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11546
11547 // wrapper function for command vkGetVideoSessionMemoryRequirementsKHR, see
11548 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetVideoSessionMemoryRequirementsKHR.html
11549 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
11550 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getVideoSessionMemoryRequirementsKHR( VideoSessionKHR videoSession,
11551 uint32_t * pMemoryRequirementsCount,
11552 VideoSessionMemoryRequirementsKHR * pMemoryRequirements,
11553 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
11554 {
11555 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
11556 return static_cast<Result>( d.vkGetVideoSessionMemoryRequirementsKHR( static_cast<VkDevice>( m_device ),
11557 static_cast<VkVideoSessionKHR>( videoSession ),
11558 pMemoryRequirementsCount,
11559 reinterpret_cast<VkVideoSessionMemoryRequirementsKHR *>( pMemoryRequirements ) ) );
11560 }
11561
11562 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11563 // wrapper function for command vkGetVideoSessionMemoryRequirementsKHR, see
11564 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetVideoSessionMemoryRequirementsKHR.html
11565 template <
11566 typename VideoSessionMemoryRequirementsKHRAllocator,
11567 typename Dispatch,
11568 typename std::enable_if<std::is_same<typename VideoSessionMemoryRequirementsKHRAllocator::value_type, VideoSessionMemoryRequirementsKHR>::value, int>::type,
11569 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
11570 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
11571 typename ResultValueType<std::vector<VideoSessionMemoryRequirementsKHR, VideoSessionMemoryRequirementsKHRAllocator>>::type
11572 Device::getVideoSessionMemoryRequirementsKHR( VideoSessionKHR videoSession, Dispatch const & d ) const
11573 {
11574 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
11575 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
11576 VULKAN_HPP_ASSERT( d.vkGetVideoSessionMemoryRequirementsKHR && "Function <vkGetVideoSessionMemoryRequirementsKHR> requires <VK_KHR_video_queue>" );
11577 # endif
11578
11579 std::vector<VideoSessionMemoryRequirementsKHR, VideoSessionMemoryRequirementsKHRAllocator> memoryRequirements;
11580 uint32_t memoryRequirementsCount;
11581 Result result;
11582 do
11583 {
11584 result = static_cast<Result>(
11585 d.vkGetVideoSessionMemoryRequirementsKHR( m_device, static_cast<VkVideoSessionKHR>( videoSession ), &memoryRequirementsCount, nullptr ) );
11586 if ( ( result == Result::eSuccess ) && memoryRequirementsCount )
11587 {
11588 memoryRequirements.resize( memoryRequirementsCount );
11589 result = static_cast<Result>(
11590 d.vkGetVideoSessionMemoryRequirementsKHR( m_device,
11591 static_cast<VkVideoSessionKHR>( videoSession ),
11592 &memoryRequirementsCount,
11593 reinterpret_cast<VkVideoSessionMemoryRequirementsKHR *>( memoryRequirements.data() ) ) );
11594 }
11595 } while ( result == Result::eIncomplete );
11596 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getVideoSessionMemoryRequirementsKHR" );
11597 VULKAN_HPP_ASSERT( memoryRequirementsCount <= memoryRequirements.size() );
11598 if ( memoryRequirementsCount < memoryRequirements.size() )
11599 {
11600 memoryRequirements.resize( memoryRequirementsCount );
11601 }
11602 return detail::createResultValueType( result, std::move( memoryRequirements ) );
11603 }
11604
11605 // wrapper function for command vkGetVideoSessionMemoryRequirementsKHR, see
11606 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetVideoSessionMemoryRequirementsKHR.html
11607 template <
11608 typename VideoSessionMemoryRequirementsKHRAllocator,
11609 typename Dispatch,
11610 typename std::enable_if<std::is_same<typename VideoSessionMemoryRequirementsKHRAllocator::value_type, VideoSessionMemoryRequirementsKHR>::value, int>::type,
11611 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
11612 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
11613 typename ResultValueType<std::vector<VideoSessionMemoryRequirementsKHR, VideoSessionMemoryRequirementsKHRAllocator>>::type
11614 Device::getVideoSessionMemoryRequirementsKHR( VideoSessionKHR videoSession,
11615 VideoSessionMemoryRequirementsKHRAllocator & videoSessionMemoryRequirementsKHRAllocator,
11616 Dispatch const & d ) const
11617 {
11618 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
11619 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
11620 VULKAN_HPP_ASSERT( d.vkGetVideoSessionMemoryRequirementsKHR && "Function <vkGetVideoSessionMemoryRequirementsKHR> requires <VK_KHR_video_queue>" );
11621 # endif
11622
11623 std::vector<VideoSessionMemoryRequirementsKHR, VideoSessionMemoryRequirementsKHRAllocator> memoryRequirements( videoSessionMemoryRequirementsKHRAllocator );
11624 uint32_t memoryRequirementsCount;
11625 Result result;
11626 do
11627 {
11628 result = static_cast<Result>(
11629 d.vkGetVideoSessionMemoryRequirementsKHR( m_device, static_cast<VkVideoSessionKHR>( videoSession ), &memoryRequirementsCount, nullptr ) );
11630 if ( ( result == Result::eSuccess ) && memoryRequirementsCount )
11631 {
11632 memoryRequirements.resize( memoryRequirementsCount );
11633 result = static_cast<Result>(
11634 d.vkGetVideoSessionMemoryRequirementsKHR( m_device,
11635 static_cast<VkVideoSessionKHR>( videoSession ),
11636 &memoryRequirementsCount,
11637 reinterpret_cast<VkVideoSessionMemoryRequirementsKHR *>( memoryRequirements.data() ) ) );
11638 }
11639 } while ( result == Result::eIncomplete );
11640 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getVideoSessionMemoryRequirementsKHR" );
11641 VULKAN_HPP_ASSERT( memoryRequirementsCount <= memoryRequirements.size() );
11642 if ( memoryRequirementsCount < memoryRequirements.size() )
11643 {
11644 memoryRequirements.resize( memoryRequirementsCount );
11645 }
11646 return detail::createResultValueType( result, std::move( memoryRequirements ) );
11647 }
11648 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11649
11650 // wrapper function for command vkBindVideoSessionMemoryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindVideoSessionMemoryKHR.html
11651 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
11652 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::bindVideoSessionMemoryKHR( VideoSessionKHR videoSession,
11653 uint32_t bindSessionMemoryInfoCount,
11654 const BindVideoSessionMemoryInfoKHR * pBindSessionMemoryInfos,
11655 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
11656 {
11657 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
11658 return static_cast<Result>( d.vkBindVideoSessionMemoryKHR( static_cast<VkDevice>( m_device ),
11659 static_cast<VkVideoSessionKHR>( videoSession ),
11660 bindSessionMemoryInfoCount,
11661 reinterpret_cast<const VkBindVideoSessionMemoryInfoKHR *>( pBindSessionMemoryInfos ) ) );
11662 }
11663
11664 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11665 // wrapper function for command vkBindVideoSessionMemoryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindVideoSessionMemoryKHR.html
11666 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
11667 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::bindVideoSessionMemoryKHR(
11668 VideoSessionKHR videoSession, ArrayProxy<const BindVideoSessionMemoryInfoKHR> const & bindSessionMemoryInfos, Dispatch const & d ) const
11669 {
11670 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
11671 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
11672 VULKAN_HPP_ASSERT( d.vkBindVideoSessionMemoryKHR && "Function <vkBindVideoSessionMemoryKHR> requires <VK_KHR_video_queue>" );
11673 # endif
11674
11675 Result result =
11676 static_cast<Result>( d.vkBindVideoSessionMemoryKHR( m_device,
11677 static_cast<VkVideoSessionKHR>( videoSession ),
11678 bindSessionMemoryInfos.size(),
11679 reinterpret_cast<const VkBindVideoSessionMemoryInfoKHR *>( bindSessionMemoryInfos.data() ) ) );
11680 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindVideoSessionMemoryKHR" );
11681
11682 return detail::createResultValueType( result );
11683 }
11684 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11685
11686 // wrapper function for command vkCreateVideoSessionParametersKHR, see
11687 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateVideoSessionParametersKHR.html
11688 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
11689 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createVideoSessionParametersKHR( const VideoSessionParametersCreateInfoKHR * pCreateInfo,
11690 const AllocationCallbacks * pAllocator,
11691 VideoSessionParametersKHR * pVideoSessionParameters,
11692 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
11693 {
11694 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
11695 return static_cast<Result>( d.vkCreateVideoSessionParametersKHR( static_cast<VkDevice>( m_device ),
11696 reinterpret_cast<const VkVideoSessionParametersCreateInfoKHR *>( pCreateInfo ),
11697 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
11698 reinterpret_cast<VkVideoSessionParametersKHR *>( pVideoSessionParameters ) ) );
11699 }
11700
11701 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11702 // wrapper function for command vkCreateVideoSessionParametersKHR, see
11703 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateVideoSessionParametersKHR.html
11704 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
11705 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VideoSessionParametersKHR>::type Device::createVideoSessionParametersKHR(
11706 const VideoSessionParametersCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
11707 {
11708 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
11709 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
11710 VULKAN_HPP_ASSERT( d.vkCreateVideoSessionParametersKHR && "Function <vkCreateVideoSessionParametersKHR> requires <VK_KHR_video_queue>" );
11711 # endif
11712
11713 VideoSessionParametersKHR videoSessionParameters;
11714 Result result = static_cast<Result>( d.vkCreateVideoSessionParametersKHR( m_device,
11715 reinterpret_cast<const VkVideoSessionParametersCreateInfoKHR *>( &createInfo ),
11716 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
11717 reinterpret_cast<VkVideoSessionParametersKHR *>( &videoSessionParameters ) ) );
11718 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createVideoSessionParametersKHR" );
11719
11720 return detail::createResultValueType( result, std::move( videoSessionParameters ) );
11721 }
11722
11723 # ifndef VULKAN_HPP_NO_SMART_HANDLE
11724 // wrapper function for command vkCreateVideoSessionParametersKHR, see
11725 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateVideoSessionParametersKHR.html
11726 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
11727 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VideoSessionParametersKHR, Dispatch>>::type
11728 Device::createVideoSessionParametersKHRUnique( const VideoSessionParametersCreateInfoKHR & createInfo,
11729 Optional<const AllocationCallbacks> allocator,
11730 Dispatch const & d ) const
11731 {
11732 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
11733 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
11734 VULKAN_HPP_ASSERT( d.vkCreateVideoSessionParametersKHR && "Function <vkCreateVideoSessionParametersKHR> requires <VK_KHR_video_queue>" );
11735 # endif
11736
11737 VideoSessionParametersKHR videoSessionParameters;
11738 Result result = static_cast<Result>( d.vkCreateVideoSessionParametersKHR( m_device,
11739 reinterpret_cast<const VkVideoSessionParametersCreateInfoKHR *>( &createInfo ),
11740 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
11741 reinterpret_cast<VkVideoSessionParametersKHR *>( &videoSessionParameters ) ) );
11742 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createVideoSessionParametersKHRUnique" );
11743
11744 return detail::createResultValueType(
11745 result, UniqueHandle<VideoSessionParametersKHR, Dispatch>( videoSessionParameters, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
11746 }
11747 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
11748 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11749
11750 // wrapper function for command vkUpdateVideoSessionParametersKHR, see
11751 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateVideoSessionParametersKHR.html
11752 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
11753 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::updateVideoSessionParametersKHR( VideoSessionParametersKHR videoSessionParameters,
11754 const VideoSessionParametersUpdateInfoKHR * pUpdateInfo,
11755 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
11756 {
11757 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
11758 return static_cast<Result>( d.vkUpdateVideoSessionParametersKHR( static_cast<VkDevice>( m_device ),
11759 static_cast<VkVideoSessionParametersKHR>( videoSessionParameters ),
11760 reinterpret_cast<const VkVideoSessionParametersUpdateInfoKHR *>( pUpdateInfo ) ) );
11761 }
11762
11763 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11764 // wrapper function for command vkUpdateVideoSessionParametersKHR, see
11765 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateVideoSessionParametersKHR.html
11766 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
11767 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::updateVideoSessionParametersKHR(
11768 VideoSessionParametersKHR videoSessionParameters, const VideoSessionParametersUpdateInfoKHR & updateInfo, Dispatch const & d ) const
11769 {
11770 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
11771 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
11772 VULKAN_HPP_ASSERT( d.vkUpdateVideoSessionParametersKHR && "Function <vkUpdateVideoSessionParametersKHR> requires <VK_KHR_video_queue>" );
11773 # endif
11774
11775 Result result =
11776 static_cast<Result>( d.vkUpdateVideoSessionParametersKHR( m_device,
11777 static_cast<VkVideoSessionParametersKHR>( videoSessionParameters ),
11778 reinterpret_cast<const VkVideoSessionParametersUpdateInfoKHR *>( &updateInfo ) ) );
11779 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::updateVideoSessionParametersKHR" );
11780
11781 return detail::createResultValueType( result );
11782 }
11783 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11784
11785 // wrapper function for command vkDestroyVideoSessionParametersKHR, see
11786 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyVideoSessionParametersKHR.html
11787 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
11788 VULKAN_HPP_INLINE void Device::destroyVideoSessionParametersKHR( VideoSessionParametersKHR videoSessionParameters,
11789 const AllocationCallbacks * pAllocator,
11790 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
11791 {
11792 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
11793 d.vkDestroyVideoSessionParametersKHR( static_cast<VkDevice>( m_device ),
11794 static_cast<VkVideoSessionParametersKHR>( videoSessionParameters ),
11795 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
11796 }
11797
11798 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11799 // wrapper function for command vkDestroyVideoSessionParametersKHR, see
11800 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyVideoSessionParametersKHR.html
11801 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
11802 VULKAN_HPP_INLINE void Device::destroyVideoSessionParametersKHR( VideoSessionParametersKHR videoSessionParameters,
11803 Optional<const AllocationCallbacks> allocator,
11804 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
11805 {
11806 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
11807 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
11808 VULKAN_HPP_ASSERT( d.vkDestroyVideoSessionParametersKHR && "Function <vkDestroyVideoSessionParametersKHR> requires <VK_KHR_video_queue>" );
11809 # endif
11810
11811 d.vkDestroyVideoSessionParametersKHR(
11812 m_device, static_cast<VkVideoSessionParametersKHR>( videoSessionParameters ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
11813 }
11814 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11815
11816 // wrapper function for command vkDestroyVideoSessionParametersKHR, see
11817 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyVideoSessionParametersKHR.html
11818 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
11819 VULKAN_HPP_INLINE void
11820 Device::destroy( VideoSessionParametersKHR videoSessionParameters, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
11821 {
11822 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
11823 d.vkDestroyVideoSessionParametersKHR( static_cast<VkDevice>( m_device ),
11824 static_cast<VkVideoSessionParametersKHR>( videoSessionParameters ),
11825 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
11826 }
11827
11828 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11829 // wrapper function for command vkDestroyVideoSessionParametersKHR, see
11830 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyVideoSessionParametersKHR.html
11831 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
11832 VULKAN_HPP_INLINE void Device::destroy( VideoSessionParametersKHR videoSessionParameters,
11833 Optional<const AllocationCallbacks> allocator,
11834 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
11835 {
11836 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
11837 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
11838 VULKAN_HPP_ASSERT( d.vkDestroyVideoSessionParametersKHR && "Function <vkDestroyVideoSessionParametersKHR> requires <VK_KHR_video_queue>" );
11839 # endif
11840
11841 d.vkDestroyVideoSessionParametersKHR(
11842 m_device, static_cast<VkVideoSessionParametersKHR>( videoSessionParameters ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
11843 }
11844 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11845
11846 // wrapper function for command vkCmdBeginVideoCodingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginVideoCodingKHR.html
11847 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
11848 VULKAN_HPP_INLINE void CommandBuffer::beginVideoCodingKHR( const VideoBeginCodingInfoKHR * pBeginInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
11849 {
11850 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
11851 d.vkCmdBeginVideoCodingKHR( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkVideoBeginCodingInfoKHR *>( pBeginInfo ) );
11852 }
11853
11854 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11855 // wrapper function for command vkCmdBeginVideoCodingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginVideoCodingKHR.html
11856 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
11857 VULKAN_HPP_INLINE void CommandBuffer::beginVideoCodingKHR( const VideoBeginCodingInfoKHR & beginInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
11858 {
11859 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
11860 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
11861 VULKAN_HPP_ASSERT( d.vkCmdBeginVideoCodingKHR && "Function <vkCmdBeginVideoCodingKHR> requires <VK_KHR_video_queue>" );
11862 # endif
11863
11864 d.vkCmdBeginVideoCodingKHR( m_commandBuffer, reinterpret_cast<const VkVideoBeginCodingInfoKHR *>( &beginInfo ) );
11865 }
11866 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11867
11868 // wrapper function for command vkCmdEndVideoCodingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndVideoCodingKHR.html
11869 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
11870 VULKAN_HPP_INLINE void CommandBuffer::endVideoCodingKHR( const VideoEndCodingInfoKHR * pEndCodingInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
11871 {
11872 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
11873 d.vkCmdEndVideoCodingKHR( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkVideoEndCodingInfoKHR *>( pEndCodingInfo ) );
11874 }
11875
11876 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11877 // wrapper function for command vkCmdEndVideoCodingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndVideoCodingKHR.html
11878 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
11879 VULKAN_HPP_INLINE void CommandBuffer::endVideoCodingKHR( const VideoEndCodingInfoKHR & endCodingInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
11880 {
11881 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
11882 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
11883 VULKAN_HPP_ASSERT( d.vkCmdEndVideoCodingKHR && "Function <vkCmdEndVideoCodingKHR> requires <VK_KHR_video_queue>" );
11884 # endif
11885
11886 d.vkCmdEndVideoCodingKHR( m_commandBuffer, reinterpret_cast<const VkVideoEndCodingInfoKHR *>( &endCodingInfo ) );
11887 }
11888 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11889
11890 // wrapper function for command vkCmdControlVideoCodingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdControlVideoCodingKHR.html
11891 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
11892 VULKAN_HPP_INLINE void CommandBuffer::controlVideoCodingKHR( const VideoCodingControlInfoKHR * pCodingControlInfo,
11893 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
11894 {
11895 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
11896 d.vkCmdControlVideoCodingKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
11897 reinterpret_cast<const VkVideoCodingControlInfoKHR *>( pCodingControlInfo ) );
11898 }
11899
11900 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11901 // wrapper function for command vkCmdControlVideoCodingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdControlVideoCodingKHR.html
11902 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
11903 VULKAN_HPP_INLINE void CommandBuffer::controlVideoCodingKHR( const VideoCodingControlInfoKHR & codingControlInfo,
11904 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
11905 {
11906 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
11907 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
11908 VULKAN_HPP_ASSERT( d.vkCmdControlVideoCodingKHR && "Function <vkCmdControlVideoCodingKHR> requires <VK_KHR_video_queue>" );
11909 # endif
11910
11911 d.vkCmdControlVideoCodingKHR( m_commandBuffer, reinterpret_cast<const VkVideoCodingControlInfoKHR *>( &codingControlInfo ) );
11912 }
11913 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11914
11915 //=== VK_KHR_video_decode_queue ===
11916
11917 // wrapper function for command vkCmdDecodeVideoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecodeVideoKHR.html
11918 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
11919 VULKAN_HPP_INLINE void CommandBuffer::decodeVideoKHR( const VideoDecodeInfoKHR * pDecodeInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
11920 {
11921 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
11922 d.vkCmdDecodeVideoKHR( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkVideoDecodeInfoKHR *>( pDecodeInfo ) );
11923 }
11924
11925 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11926 // wrapper function for command vkCmdDecodeVideoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecodeVideoKHR.html
11927 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
11928 VULKAN_HPP_INLINE void CommandBuffer::decodeVideoKHR( const VideoDecodeInfoKHR & decodeInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
11929 {
11930 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
11931 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
11932 VULKAN_HPP_ASSERT( d.vkCmdDecodeVideoKHR && "Function <vkCmdDecodeVideoKHR> requires <VK_KHR_video_decode_queue>" );
11933 # endif
11934
11935 d.vkCmdDecodeVideoKHR( m_commandBuffer, reinterpret_cast<const VkVideoDecodeInfoKHR *>( &decodeInfo ) );
11936 }
11937 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11938
11939 //=== VK_EXT_transform_feedback ===
11940
11941 // wrapper function for command vkCmdBindTransformFeedbackBuffersEXT, see
11942 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindTransformFeedbackBuffersEXT.html
11943 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
11944 VULKAN_HPP_INLINE void CommandBuffer::bindTransformFeedbackBuffersEXT( uint32_t firstBinding,
11945 uint32_t bindingCount,
11946 const Buffer * pBuffers,
11947 const DeviceSize * pOffsets,
11948 const DeviceSize * pSizes,
11949 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
11950 {
11951 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
11952 d.vkCmdBindTransformFeedbackBuffersEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
11953 firstBinding,
11954 bindingCount,
11955 reinterpret_cast<const VkBuffer *>( pBuffers ),
11956 reinterpret_cast<const VkDeviceSize *>( pOffsets ),
11957 reinterpret_cast<const VkDeviceSize *>( pSizes ) );
11958 }
11959
11960 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11961 // wrapper function for command vkCmdBindTransformFeedbackBuffersEXT, see
11962 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindTransformFeedbackBuffersEXT.html
11963 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
11964 VULKAN_HPP_INLINE void CommandBuffer::bindTransformFeedbackBuffersEXT( uint32_t firstBinding,
11965 ArrayProxy<const Buffer> const & buffers,
11966 ArrayProxy<const DeviceSize> const & offsets,
11967 ArrayProxy<const DeviceSize> const & sizes,
11968 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
11969 {
11970 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
11971 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
11972 VULKAN_HPP_ASSERT( d.vkCmdBindTransformFeedbackBuffersEXT && "Function <vkCmdBindTransformFeedbackBuffersEXT> requires <VK_EXT_transform_feedback>" );
11973 # endif
11974 # ifdef VULKAN_HPP_NO_EXCEPTIONS
11975 VULKAN_HPP_ASSERT( buffers.size() == offsets.size() );
11976 VULKAN_HPP_ASSERT( sizes.empty() || buffers.size() == sizes.size() );
11977 # else
11978 if ( buffers.size() != offsets.size() )
11979 {
11980 throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindTransformFeedbackBuffersEXT: buffers.size() != offsets.size()" );
11981 }
11982 if ( !sizes.empty() && buffers.size() != sizes.size() )
11983 {
11984 throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindTransformFeedbackBuffersEXT: buffers.size() != sizes.size()" );
11985 }
11986 # endif /*VULKAN_HPP_NO_EXCEPTIONS*/
11987
11988 d.vkCmdBindTransformFeedbackBuffersEXT( m_commandBuffer,
11989 firstBinding,
11990 buffers.size(),
11991 reinterpret_cast<const VkBuffer *>( buffers.data() ),
11992 reinterpret_cast<const VkDeviceSize *>( offsets.data() ),
11993 reinterpret_cast<const VkDeviceSize *>( sizes.data() ) );
11994 }
11995 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11996
11997 // wrapper function for command vkCmdBeginTransformFeedbackEXT, see
11998 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginTransformFeedbackEXT.html
11999 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
12000 VULKAN_HPP_INLINE void CommandBuffer::beginTransformFeedbackEXT( uint32_t firstCounterBuffer,
12001 uint32_t counterBufferCount,
12002 const Buffer * pCounterBuffers,
12003 const DeviceSize * pCounterBufferOffsets,
12004 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
12005 {
12006 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
12007 d.vkCmdBeginTransformFeedbackEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
12008 firstCounterBuffer,
12009 counterBufferCount,
12010 reinterpret_cast<const VkBuffer *>( pCounterBuffers ),
12011 reinterpret_cast<const VkDeviceSize *>( pCounterBufferOffsets ) );
12012 }
12013
12014 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12015 // wrapper function for command vkCmdBeginTransformFeedbackEXT, see
12016 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginTransformFeedbackEXT.html
12017 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
12018 VULKAN_HPP_INLINE void CommandBuffer::beginTransformFeedbackEXT( uint32_t firstCounterBuffer,
12019 ArrayProxy<const Buffer> const & counterBuffers,
12020 ArrayProxy<const DeviceSize> const & counterBufferOffsets,
12021 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
12022 {
12023 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
12024 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
12025 VULKAN_HPP_ASSERT( d.vkCmdBeginTransformFeedbackEXT && "Function <vkCmdBeginTransformFeedbackEXT> requires <VK_EXT_transform_feedback>" );
12026 # endif
12027 # ifdef VULKAN_HPP_NO_EXCEPTIONS
12028 VULKAN_HPP_ASSERT( counterBufferOffsets.empty() || counterBuffers.size() == counterBufferOffsets.size() );
12029 # else
12030 if ( !counterBufferOffsets.empty() && counterBuffers.size() != counterBufferOffsets.size() )
12031 {
12032 throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::beginTransformFeedbackEXT: counterBuffers.size() != counterBufferOffsets.size()" );
12033 }
12034 # endif /*VULKAN_HPP_NO_EXCEPTIONS*/
12035
12036 d.vkCmdBeginTransformFeedbackEXT( m_commandBuffer,
12037 firstCounterBuffer,
12038 counterBuffers.size(),
12039 reinterpret_cast<const VkBuffer *>( counterBuffers.data() ),
12040 reinterpret_cast<const VkDeviceSize *>( counterBufferOffsets.data() ) );
12041 }
12042 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12043
12044 // wrapper function for command vkCmdEndTransformFeedbackEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndTransformFeedbackEXT.html
12045 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
12046 VULKAN_HPP_INLINE void CommandBuffer::endTransformFeedbackEXT( uint32_t firstCounterBuffer,
12047 uint32_t counterBufferCount,
12048 const Buffer * pCounterBuffers,
12049 const DeviceSize * pCounterBufferOffsets,
12050 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
12051 {
12052 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
12053 d.vkCmdEndTransformFeedbackEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
12054 firstCounterBuffer,
12055 counterBufferCount,
12056 reinterpret_cast<const VkBuffer *>( pCounterBuffers ),
12057 reinterpret_cast<const VkDeviceSize *>( pCounterBufferOffsets ) );
12058 }
12059
12060 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12061 // wrapper function for command vkCmdEndTransformFeedbackEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndTransformFeedbackEXT.html
12062 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
12063 VULKAN_HPP_INLINE void CommandBuffer::endTransformFeedbackEXT( uint32_t firstCounterBuffer,
12064 ArrayProxy<const Buffer> const & counterBuffers,
12065 ArrayProxy<const DeviceSize> const & counterBufferOffsets,
12066 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
12067 {
12068 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
12069 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
12070 VULKAN_HPP_ASSERT( d.vkCmdEndTransformFeedbackEXT && "Function <vkCmdEndTransformFeedbackEXT> requires <VK_EXT_transform_feedback>" );
12071 # endif
12072 # ifdef VULKAN_HPP_NO_EXCEPTIONS
12073 VULKAN_HPP_ASSERT( counterBufferOffsets.empty() || counterBuffers.size() == counterBufferOffsets.size() );
12074 # else
12075 if ( !counterBufferOffsets.empty() && counterBuffers.size() != counterBufferOffsets.size() )
12076 {
12077 throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::endTransformFeedbackEXT: counterBuffers.size() != counterBufferOffsets.size()" );
12078 }
12079 # endif /*VULKAN_HPP_NO_EXCEPTIONS*/
12080
12081 d.vkCmdEndTransformFeedbackEXT( m_commandBuffer,
12082 firstCounterBuffer,
12083 counterBuffers.size(),
12084 reinterpret_cast<const VkBuffer *>( counterBuffers.data() ),
12085 reinterpret_cast<const VkDeviceSize *>( counterBufferOffsets.data() ) );
12086 }
12087 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12088
12089 // wrapper function for command vkCmdBeginQueryIndexedEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginQueryIndexedEXT.html
12090 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
12091 VULKAN_HPP_INLINE void CommandBuffer::beginQueryIndexedEXT(
12092 QueryPool queryPool, uint32_t query, QueryControlFlags flags, uint32_t index, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
12093 {
12094 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
12095 d.vkCmdBeginQueryIndexedEXT(
12096 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkQueryPool>( queryPool ), query, static_cast<VkQueryControlFlags>( flags ), index );
12097 }
12098
12099 // wrapper function for command vkCmdEndQueryIndexedEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndQueryIndexedEXT.html
12100 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
12101 VULKAN_HPP_INLINE void CommandBuffer::endQueryIndexedEXT( QueryPool queryPool, uint32_t query, uint32_t index, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
12102 {
12103 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
12104 d.vkCmdEndQueryIndexedEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkQueryPool>( queryPool ), query, index );
12105 }
12106
12107 // wrapper function for command vkCmdDrawIndirectByteCountEXT, see
12108 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirectByteCountEXT.html
12109 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
12110 VULKAN_HPP_INLINE void CommandBuffer::drawIndirectByteCountEXT( uint32_t instanceCount,
12111 uint32_t firstInstance,
12112 Buffer counterBuffer,
12113 DeviceSize counterBufferOffset,
12114 uint32_t counterOffset,
12115 uint32_t vertexStride,
12116 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
12117 {
12118 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
12119 d.vkCmdDrawIndirectByteCountEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
12120 instanceCount,
12121 firstInstance,
12122 static_cast<VkBuffer>( counterBuffer ),
12123 static_cast<VkDeviceSize>( counterBufferOffset ),
12124 counterOffset,
12125 vertexStride );
12126 }
12127
12128 //=== VK_NVX_binary_import ===
12129
12130 // wrapper function for command vkCreateCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCuModuleNVX.html
12131 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
12132 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createCuModuleNVX( const CuModuleCreateInfoNVX * pCreateInfo,
12133 const AllocationCallbacks * pAllocator,
12134 CuModuleNVX * pModule,
12135 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
12136 {
12137 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
12138 return static_cast<Result>( d.vkCreateCuModuleNVX( static_cast<VkDevice>( m_device ),
12139 reinterpret_cast<const VkCuModuleCreateInfoNVX *>( pCreateInfo ),
12140 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
12141 reinterpret_cast<VkCuModuleNVX *>( pModule ) ) );
12142 }
12143
12144 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12145 // wrapper function for command vkCreateCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCuModuleNVX.html
12146 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
12147 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<CuModuleNVX>::type
12148 Device::createCuModuleNVX( const CuModuleCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
12149 {
12150 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
12151 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
12152 VULKAN_HPP_ASSERT( d.vkCreateCuModuleNVX && "Function <vkCreateCuModuleNVX> requires <VK_NVX_binary_import>" );
12153 # endif
12154
12155 CuModuleNVX module;
12156 Result result = static_cast<Result>( d.vkCreateCuModuleNVX( m_device,
12157 reinterpret_cast<const VkCuModuleCreateInfoNVX *>( &createInfo ),
12158 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
12159 reinterpret_cast<VkCuModuleNVX *>( &module ) ) );
12160 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createCuModuleNVX" );
12161
12162 return detail::createResultValueType( result, std::move( module ) );
12163 }
12164
12165 # ifndef VULKAN_HPP_NO_SMART_HANDLE
12166 // wrapper function for command vkCreateCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCuModuleNVX.html
12167 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
12168 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<CuModuleNVX, Dispatch>>::type
12169 Device::createCuModuleNVXUnique( const CuModuleCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
12170 {
12171 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
12172 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
12173 VULKAN_HPP_ASSERT( d.vkCreateCuModuleNVX && "Function <vkCreateCuModuleNVX> requires <VK_NVX_binary_import>" );
12174 # endif
12175
12176 CuModuleNVX module;
12177 Result result = static_cast<Result>( d.vkCreateCuModuleNVX( m_device,
12178 reinterpret_cast<const VkCuModuleCreateInfoNVX *>( &createInfo ),
12179 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
12180 reinterpret_cast<VkCuModuleNVX *>( &module ) ) );
12181 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createCuModuleNVXUnique" );
12182
12183 return detail::createResultValueType( result,
12184 UniqueHandle<CuModuleNVX, Dispatch>( module, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
12185 }
12186 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
12187 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12188
12189 // wrapper function for command vkCreateCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCuFunctionNVX.html
12190 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
12191 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createCuFunctionNVX( const CuFunctionCreateInfoNVX * pCreateInfo,
12192 const AllocationCallbacks * pAllocator,
12193 CuFunctionNVX * pFunction,
12194 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
12195 {
12196 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
12197 return static_cast<Result>( d.vkCreateCuFunctionNVX( static_cast<VkDevice>( m_device ),
12198 reinterpret_cast<const VkCuFunctionCreateInfoNVX *>( pCreateInfo ),
12199 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
12200 reinterpret_cast<VkCuFunctionNVX *>( pFunction ) ) );
12201 }
12202
12203 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12204 // wrapper function for command vkCreateCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCuFunctionNVX.html
12205 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
12206 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<CuFunctionNVX>::type
12207 Device::createCuFunctionNVX( const CuFunctionCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
12208 {
12209 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
12210 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
12211 VULKAN_HPP_ASSERT( d.vkCreateCuFunctionNVX && "Function <vkCreateCuFunctionNVX> requires <VK_NVX_binary_import>" );
12212 # endif
12213
12214 CuFunctionNVX function;
12215 Result result = static_cast<Result>( d.vkCreateCuFunctionNVX( m_device,
12216 reinterpret_cast<const VkCuFunctionCreateInfoNVX *>( &createInfo ),
12217 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
12218 reinterpret_cast<VkCuFunctionNVX *>( &function ) ) );
12219 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createCuFunctionNVX" );
12220
12221 return detail::createResultValueType( result, std::move( function ) );
12222 }
12223
12224 # ifndef VULKAN_HPP_NO_SMART_HANDLE
12225 // wrapper function for command vkCreateCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCuFunctionNVX.html
12226 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
12227 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<CuFunctionNVX, Dispatch>>::type
12228 Device::createCuFunctionNVXUnique( const CuFunctionCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
12229 {
12230 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
12231 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
12232 VULKAN_HPP_ASSERT( d.vkCreateCuFunctionNVX && "Function <vkCreateCuFunctionNVX> requires <VK_NVX_binary_import>" );
12233 # endif
12234
12235 CuFunctionNVX function;
12236 Result result = static_cast<Result>( d.vkCreateCuFunctionNVX( m_device,
12237 reinterpret_cast<const VkCuFunctionCreateInfoNVX *>( &createInfo ),
12238 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
12239 reinterpret_cast<VkCuFunctionNVX *>( &function ) ) );
12240 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createCuFunctionNVXUnique" );
12241
12242 return detail::createResultValueType( result,
12243 UniqueHandle<CuFunctionNVX, Dispatch>( function, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
12244 }
12245 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
12246 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12247
12248 // wrapper function for command vkDestroyCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCuModuleNVX.html
12249 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
12250 VULKAN_HPP_INLINE void Device::destroyCuModuleNVX( CuModuleNVX module, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
12251 {
12252 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
12253 d.vkDestroyCuModuleNVX(
12254 static_cast<VkDevice>( m_device ), static_cast<VkCuModuleNVX>( module ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
12255 }
12256
12257 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12258 // wrapper function for command vkDestroyCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCuModuleNVX.html
12259 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
12260 VULKAN_HPP_INLINE void
12261 Device::destroyCuModuleNVX( CuModuleNVX module, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
12262 {
12263 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
12264 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
12265 VULKAN_HPP_ASSERT( d.vkDestroyCuModuleNVX && "Function <vkDestroyCuModuleNVX> requires <VK_NVX_binary_import>" );
12266 # endif
12267
12268 d.vkDestroyCuModuleNVX( m_device, static_cast<VkCuModuleNVX>( module ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
12269 }
12270 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12271
12272 // wrapper function for command vkDestroyCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCuModuleNVX.html
12273 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
12274 VULKAN_HPP_INLINE void Device::destroy( CuModuleNVX module, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
12275 {
12276 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
12277 d.vkDestroyCuModuleNVX(
12278 static_cast<VkDevice>( m_device ), static_cast<VkCuModuleNVX>( module ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
12279 }
12280
12281 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12282 // wrapper function for command vkDestroyCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCuModuleNVX.html
12283 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
12284 VULKAN_HPP_INLINE void Device::destroy( CuModuleNVX module, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
12285 {
12286 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
12287 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
12288 VULKAN_HPP_ASSERT( d.vkDestroyCuModuleNVX && "Function <vkDestroyCuModuleNVX> requires <VK_NVX_binary_import>" );
12289 # endif
12290
12291 d.vkDestroyCuModuleNVX( m_device, static_cast<VkCuModuleNVX>( module ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
12292 }
12293 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12294
12295 // wrapper function for command vkDestroyCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCuFunctionNVX.html
12296 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
12297 VULKAN_HPP_INLINE void
12298 Device::destroyCuFunctionNVX( CuFunctionNVX function, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
12299 {
12300 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
12301 d.vkDestroyCuFunctionNVX(
12302 static_cast<VkDevice>( m_device ), static_cast<VkCuFunctionNVX>( function ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
12303 }
12304
12305 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12306 // wrapper function for command vkDestroyCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCuFunctionNVX.html
12307 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
12308 VULKAN_HPP_INLINE void
12309 Device::destroyCuFunctionNVX( CuFunctionNVX function, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
12310 {
12311 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
12312 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
12313 VULKAN_HPP_ASSERT( d.vkDestroyCuFunctionNVX && "Function <vkDestroyCuFunctionNVX> requires <VK_NVX_binary_import>" );
12314 # endif
12315
12316 d.vkDestroyCuFunctionNVX( m_device, static_cast<VkCuFunctionNVX>( function ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
12317 }
12318 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12319
12320 // wrapper function for command vkDestroyCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCuFunctionNVX.html
12321 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
12322 VULKAN_HPP_INLINE void Device::destroy( CuFunctionNVX function, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
12323 {
12324 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
12325 d.vkDestroyCuFunctionNVX(
12326 static_cast<VkDevice>( m_device ), static_cast<VkCuFunctionNVX>( function ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
12327 }
12328
12329 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12330 // wrapper function for command vkDestroyCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCuFunctionNVX.html
12331 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
12332 VULKAN_HPP_INLINE void Device::destroy( CuFunctionNVX function, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
12333 {
12334 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
12335 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
12336 VULKAN_HPP_ASSERT( d.vkDestroyCuFunctionNVX && "Function <vkDestroyCuFunctionNVX> requires <VK_NVX_binary_import>" );
12337 # endif
12338
12339 d.vkDestroyCuFunctionNVX( m_device, static_cast<VkCuFunctionNVX>( function ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
12340 }
12341 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12342
12343 // wrapper function for command vkCmdCuLaunchKernelNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCuLaunchKernelNVX.html
12344 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
12345 VULKAN_HPP_INLINE void CommandBuffer::cuLaunchKernelNVX( const CuLaunchInfoNVX * pLaunchInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
12346 {
12347 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
12348 d.vkCmdCuLaunchKernelNVX( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkCuLaunchInfoNVX *>( pLaunchInfo ) );
12349 }
12350
12351 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12352 // wrapper function for command vkCmdCuLaunchKernelNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCuLaunchKernelNVX.html
12353 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
12354 VULKAN_HPP_INLINE void CommandBuffer::cuLaunchKernelNVX( const CuLaunchInfoNVX & launchInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
12355 {
12356 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
12357 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
12358 VULKAN_HPP_ASSERT( d.vkCmdCuLaunchKernelNVX && "Function <vkCmdCuLaunchKernelNVX> requires <VK_NVX_binary_import>" );
12359 # endif
12360
12361 d.vkCmdCuLaunchKernelNVX( m_commandBuffer, reinterpret_cast<const VkCuLaunchInfoNVX *>( &launchInfo ) );
12362 }
12363 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12364
12365 //=== VK_NVX_image_view_handle ===
12366
12367 // wrapper function for command vkGetImageViewHandleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewHandleNVX.html
12368 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
12369 VULKAN_HPP_INLINE uint32_t Device::getImageViewHandleNVX( const ImageViewHandleInfoNVX * pInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
12370 {
12371 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
12372 return d.vkGetImageViewHandleNVX( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkImageViewHandleInfoNVX *>( pInfo ) );
12373 }
12374
12375 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12376 // wrapper function for command vkGetImageViewHandleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewHandleNVX.html
12377 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
12378 VULKAN_HPP_INLINE uint32_t Device::getImageViewHandleNVX( const ImageViewHandleInfoNVX & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
12379 {
12380 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
12381 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
12382 VULKAN_HPP_ASSERT( d.vkGetImageViewHandleNVX && "Function <vkGetImageViewHandleNVX> requires <VK_NVX_image_view_handle>" );
12383 # endif
12384
12385 uint32_t result = d.vkGetImageViewHandleNVX( m_device, reinterpret_cast<const VkImageViewHandleInfoNVX *>( &info ) );
12386
12387 return result;
12388 }
12389 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12390
12391 // wrapper function for command vkGetImageViewHandle64NVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewHandle64NVX.html
12392 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
12393 VULKAN_HPP_INLINE uint64_t Device::getImageViewHandle64NVX( const ImageViewHandleInfoNVX * pInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
12394 {
12395 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
12396 return d.vkGetImageViewHandle64NVX( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkImageViewHandleInfoNVX *>( pInfo ) );
12397 }
12398
12399 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12400 // wrapper function for command vkGetImageViewHandle64NVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewHandle64NVX.html
12401 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
12402 VULKAN_HPP_INLINE uint64_t Device::getImageViewHandle64NVX( const ImageViewHandleInfoNVX & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
12403 {
12404 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
12405 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
12406 VULKAN_HPP_ASSERT( d.vkGetImageViewHandle64NVX && "Function <vkGetImageViewHandle64NVX> requires <VK_NVX_image_view_handle>" );
12407 # endif
12408
12409 uint64_t result = d.vkGetImageViewHandle64NVX( m_device, reinterpret_cast<const VkImageViewHandleInfoNVX *>( &info ) );
12410
12411 return result;
12412 }
12413 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12414
12415 // wrapper function for command vkGetImageViewAddressNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewAddressNVX.html
12416 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
12417 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getImageViewAddressNVX( ImageView imageView,
12418 ImageViewAddressPropertiesNVX * pProperties,
12419 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
12420 {
12421 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
12422 return static_cast<Result>( d.vkGetImageViewAddressNVX(
12423 static_cast<VkDevice>( m_device ), static_cast<VkImageView>( imageView ), reinterpret_cast<VkImageViewAddressPropertiesNVX *>( pProperties ) ) );
12424 }
12425
12426 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12427 // wrapper function for command vkGetImageViewAddressNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewAddressNVX.html
12428 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
12429 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<ImageViewAddressPropertiesNVX>::type
12430 Device::getImageViewAddressNVX( ImageView imageView, Dispatch const & d ) const
12431 {
12432 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
12433 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
12434 VULKAN_HPP_ASSERT( d.vkGetImageViewAddressNVX && "Function <vkGetImageViewAddressNVX> requires <VK_NVX_image_view_handle>" );
12435 # endif
12436
12437 ImageViewAddressPropertiesNVX properties;
12438 Result result = static_cast<Result>(
12439 d.vkGetImageViewAddressNVX( m_device, static_cast<VkImageView>( imageView ), reinterpret_cast<VkImageViewAddressPropertiesNVX *>( &properties ) ) );
12440 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getImageViewAddressNVX" );
12441
12442 return detail::createResultValueType( result, std::move( properties ) );
12443 }
12444 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12445
12446 //=== VK_AMD_draw_indirect_count ===
12447
12448 // wrapper function for command vkCmdDrawIndirectCountAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirectCountAMD.html
12449 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
12450 VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountAMD( Buffer buffer,
12451 DeviceSize offset,
12452 Buffer countBuffer,
12453 DeviceSize countBufferOffset,
12454 uint32_t maxDrawCount,
12455 uint32_t stride,
12456 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
12457 {
12458 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
12459 d.vkCmdDrawIndirectCountAMD( static_cast<VkCommandBuffer>( m_commandBuffer ),
12460 static_cast<VkBuffer>( buffer ),
12461 static_cast<VkDeviceSize>( offset ),
12462 static_cast<VkBuffer>( countBuffer ),
12463 static_cast<VkDeviceSize>( countBufferOffset ),
12464 maxDrawCount,
12465 stride );
12466 }
12467
12468 // wrapper function for command vkCmdDrawIndexedIndirectCountAMD, see
12469 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexedIndirectCountAMD.html
12470 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
12471 VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountAMD( Buffer buffer,
12472 DeviceSize offset,
12473 Buffer countBuffer,
12474 DeviceSize countBufferOffset,
12475 uint32_t maxDrawCount,
12476 uint32_t stride,
12477 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
12478 {
12479 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
12480 d.vkCmdDrawIndexedIndirectCountAMD( static_cast<VkCommandBuffer>( m_commandBuffer ),
12481 static_cast<VkBuffer>( buffer ),
12482 static_cast<VkDeviceSize>( offset ),
12483 static_cast<VkBuffer>( countBuffer ),
12484 static_cast<VkDeviceSize>( countBufferOffset ),
12485 maxDrawCount,
12486 stride );
12487 }
12488
12489 //=== VK_AMD_shader_info ===
12490
12491 // wrapper function for command vkGetShaderInfoAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderInfoAMD.html
12492 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
12493 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getShaderInfoAMD( Pipeline pipeline,
12494 ShaderStageFlagBits shaderStage,
12495 ShaderInfoTypeAMD infoType,
12496 size_t * pInfoSize,
12497 void * pInfo,
12498 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
12499 {
12500 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
12501 return static_cast<Result>( d.vkGetShaderInfoAMD( static_cast<VkDevice>( m_device ),
12502 static_cast<VkPipeline>( pipeline ),
12503 static_cast<VkShaderStageFlagBits>( shaderStage ),
12504 static_cast<VkShaderInfoTypeAMD>( infoType ),
12505 pInfoSize,
12506 pInfo ) );
12507 }
12508
12509 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12510 // wrapper function for command vkGetShaderInfoAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderInfoAMD.html
12511 template <typename Uint8_tAllocator,
12512 typename Dispatch,
12513 typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type,
12514 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
12515 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
12516 Device::getShaderInfoAMD( Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType, Dispatch const & d ) const
12517 {
12518 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
12519 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
12520 VULKAN_HPP_ASSERT( d.vkGetShaderInfoAMD && "Function <vkGetShaderInfoAMD> requires <VK_AMD_shader_info>" );
12521 # endif
12522
12523 std::vector<uint8_t, Uint8_tAllocator> info;
12524 size_t infoSize;
12525 Result result;
12526 do
12527 {
12528 result = static_cast<Result>( d.vkGetShaderInfoAMD( m_device,
12529 static_cast<VkPipeline>( pipeline ),
12530 static_cast<VkShaderStageFlagBits>( shaderStage ),
12531 static_cast<VkShaderInfoTypeAMD>( infoType ),
12532 &infoSize,
12533 nullptr ) );
12534 if ( ( result == Result::eSuccess ) && infoSize )
12535 {
12536 info.resize( infoSize );
12537 result = static_cast<Result>( d.vkGetShaderInfoAMD( m_device,
12538 static_cast<VkPipeline>( pipeline ),
12539 static_cast<VkShaderStageFlagBits>( shaderStage ),
12540 static_cast<VkShaderInfoTypeAMD>( infoType ),
12541 &infoSize,
12542 reinterpret_cast<void *>( info.data() ) ) );
12543 }
12544 } while ( result == Result::eIncomplete );
12545 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getShaderInfoAMD" );
12546 VULKAN_HPP_ASSERT( infoSize <= info.size() );
12547 if ( infoSize < info.size() )
12548 {
12549 info.resize( infoSize );
12550 }
12551 return detail::createResultValueType( result, std::move( info ) );
12552 }
12553
12554 // wrapper function for command vkGetShaderInfoAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderInfoAMD.html
12555 template <typename Uint8_tAllocator,
12556 typename Dispatch,
12557 typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type,
12558 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
12559 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type Device::getShaderInfoAMD(
12560 Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType, Uint8_tAllocator & uint8_tAllocator, Dispatch const & d ) const
12561 {
12562 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
12563 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
12564 VULKAN_HPP_ASSERT( d.vkGetShaderInfoAMD && "Function <vkGetShaderInfoAMD> requires <VK_AMD_shader_info>" );
12565 # endif
12566
12567 std::vector<uint8_t, Uint8_tAllocator> info( uint8_tAllocator );
12568 size_t infoSize;
12569 Result result;
12570 do
12571 {
12572 result = static_cast<Result>( d.vkGetShaderInfoAMD( m_device,
12573 static_cast<VkPipeline>( pipeline ),
12574 static_cast<VkShaderStageFlagBits>( shaderStage ),
12575 static_cast<VkShaderInfoTypeAMD>( infoType ),
12576 &infoSize,
12577 nullptr ) );
12578 if ( ( result == Result::eSuccess ) && infoSize )
12579 {
12580 info.resize( infoSize );
12581 result = static_cast<Result>( d.vkGetShaderInfoAMD( m_device,
12582 static_cast<VkPipeline>( pipeline ),
12583 static_cast<VkShaderStageFlagBits>( shaderStage ),
12584 static_cast<VkShaderInfoTypeAMD>( infoType ),
12585 &infoSize,
12586 reinterpret_cast<void *>( info.data() ) ) );
12587 }
12588 } while ( result == Result::eIncomplete );
12589 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getShaderInfoAMD" );
12590 VULKAN_HPP_ASSERT( infoSize <= info.size() );
12591 if ( infoSize < info.size() )
12592 {
12593 info.resize( infoSize );
12594 }
12595 return detail::createResultValueType( result, std::move( info ) );
12596 }
12597 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12598
12599 //=== VK_KHR_dynamic_rendering ===
12600
12601 // wrapper function for command vkCmdBeginRenderingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderingKHR.html
12602 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
12603 VULKAN_HPP_INLINE void CommandBuffer::beginRenderingKHR( const RenderingInfo * pRenderingInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
12604 {
12605 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
12606 d.vkCmdBeginRenderingKHR( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkRenderingInfo *>( pRenderingInfo ) );
12607 }
12608
12609 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12610 // wrapper function for command vkCmdBeginRenderingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderingKHR.html
12611 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
12612 VULKAN_HPP_INLINE void CommandBuffer::beginRenderingKHR( const RenderingInfo & renderingInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
12613 {
12614 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
12615 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
12616 VULKAN_HPP_ASSERT( d.vkCmdBeginRenderingKHR && "Function <vkCmdBeginRenderingKHR> requires <VK_KHR_dynamic_rendering> or <VK_VERSION_1_3>" );
12617 # endif
12618
12619 d.vkCmdBeginRenderingKHR( m_commandBuffer, reinterpret_cast<const VkRenderingInfo *>( &renderingInfo ) );
12620 }
12621 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12622
12623 // wrapper function for command vkCmdEndRenderingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderingKHR.html
12624 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
12625 VULKAN_HPP_INLINE void CommandBuffer::endRenderingKHR( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
12626 {
12627 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
12628 d.vkCmdEndRenderingKHR( static_cast<VkCommandBuffer>( m_commandBuffer ) );
12629 }
12630
12631 #if defined( VK_USE_PLATFORM_GGP )
12632 //=== VK_GGP_stream_descriptor_surface ===
12633
12634 // wrapper function for command vkCreateStreamDescriptorSurfaceGGP, see
12635 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateStreamDescriptorSurfaceGGP.html
12636 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
12637 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createStreamDescriptorSurfaceGGP( const StreamDescriptorSurfaceCreateInfoGGP * pCreateInfo,
12638 const AllocationCallbacks * pAllocator,
12639 SurfaceKHR * pSurface,
12640 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
12641 {
12642 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
12643 return static_cast<Result>( d.vkCreateStreamDescriptorSurfaceGGP( static_cast<VkInstance>( m_instance ),
12644 reinterpret_cast<const VkStreamDescriptorSurfaceCreateInfoGGP *>( pCreateInfo ),
12645 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
12646 reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) );
12647 }
12648
12649 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12650 // wrapper function for command vkCreateStreamDescriptorSurfaceGGP, see
12651 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateStreamDescriptorSurfaceGGP.html
12652 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
12653 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<SurfaceKHR>::type Instance::createStreamDescriptorSurfaceGGP(
12654 const StreamDescriptorSurfaceCreateInfoGGP & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
12655 {
12656 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
12657 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
12658 VULKAN_HPP_ASSERT( d.vkCreateStreamDescriptorSurfaceGGP && "Function <vkCreateStreamDescriptorSurfaceGGP> requires <VK_GGP_stream_descriptor_surface>" );
12659 # endif
12660
12661 SurfaceKHR surface;
12662 Result result = static_cast<Result>( d.vkCreateStreamDescriptorSurfaceGGP( m_instance,
12663 reinterpret_cast<const VkStreamDescriptorSurfaceCreateInfoGGP *>( &createInfo ),
12664 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
12665 reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
12666 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createStreamDescriptorSurfaceGGP" );
12667
12668 return detail::createResultValueType( result, std::move( surface ) );
12669 }
12670
12671 # ifndef VULKAN_HPP_NO_SMART_HANDLE
12672 // wrapper function for command vkCreateStreamDescriptorSurfaceGGP, see
12673 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateStreamDescriptorSurfaceGGP.html
12674 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
12675 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type Instance::createStreamDescriptorSurfaceGGPUnique(
12676 const StreamDescriptorSurfaceCreateInfoGGP & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
12677 {
12678 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
12679 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
12680 VULKAN_HPP_ASSERT( d.vkCreateStreamDescriptorSurfaceGGP && "Function <vkCreateStreamDescriptorSurfaceGGP> requires <VK_GGP_stream_descriptor_surface>" );
12681 # endif
12682
12683 SurfaceKHR surface;
12684 Result result = static_cast<Result>( d.vkCreateStreamDescriptorSurfaceGGP( m_instance,
12685 reinterpret_cast<const VkStreamDescriptorSurfaceCreateInfoGGP *>( &createInfo ),
12686 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
12687 reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
12688 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createStreamDescriptorSurfaceGGPUnique" );
12689
12690 return detail::createResultValueType( result,
12691 UniqueHandle<SurfaceKHR, Dispatch>( surface, detail::ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) );
12692 }
12693 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
12694 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12695 #endif /*VK_USE_PLATFORM_GGP*/
12696
12697 //=== VK_NV_external_memory_capabilities ===
12698
12699 // wrapper function for command vkGetPhysicalDeviceExternalImageFormatPropertiesNV, see
12700 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalImageFormatPropertiesNV.html
12701 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
12702 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
12703 PhysicalDevice::getExternalImageFormatPropertiesNV( Format format,
12704 ImageType type,
12705 ImageTiling tiling,
12706 ImageUsageFlags usage,
12707 ImageCreateFlags flags,
12708 ExternalMemoryHandleTypeFlagsNV externalHandleType,
12709 ExternalImageFormatPropertiesNV * pExternalImageFormatProperties,
12710 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
12711 {
12712 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
12713 return static_cast<Result>(
12714 d.vkGetPhysicalDeviceExternalImageFormatPropertiesNV( static_cast<VkPhysicalDevice>( m_physicalDevice ),
12715 static_cast<VkFormat>( format ),
12716 static_cast<VkImageType>( type ),
12717 static_cast<VkImageTiling>( tiling ),
12718 static_cast<VkImageUsageFlags>( usage ),
12719 static_cast<VkImageCreateFlags>( flags ),
12720 static_cast<VkExternalMemoryHandleTypeFlagsNV>( externalHandleType ),
12721 reinterpret_cast<VkExternalImageFormatPropertiesNV *>( pExternalImageFormatProperties ) ) );
12722 }
12723
12724 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12725 // wrapper function for command vkGetPhysicalDeviceExternalImageFormatPropertiesNV, see
12726 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalImageFormatPropertiesNV.html
12727 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
12728 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<ExternalImageFormatPropertiesNV>::type
12729 PhysicalDevice::getExternalImageFormatPropertiesNV( Format format,
12730 ImageType type,
12731 ImageTiling tiling,
12732 ImageUsageFlags usage,
12733 ImageCreateFlags flags,
12734 ExternalMemoryHandleTypeFlagsNV externalHandleType,
12735 Dispatch const & d ) const
12736 {
12737 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
12738 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
12739 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceExternalImageFormatPropertiesNV &&
12740 "Function <vkGetPhysicalDeviceExternalImageFormatPropertiesNV> requires <VK_NV_external_memory_capabilities>" );
12741 # endif
12742
12743 ExternalImageFormatPropertiesNV externalImageFormatProperties;
12744 Result result = static_cast<Result>(
12745 d.vkGetPhysicalDeviceExternalImageFormatPropertiesNV( m_physicalDevice,
12746 static_cast<VkFormat>( format ),
12747 static_cast<VkImageType>( type ),
12748 static_cast<VkImageTiling>( tiling ),
12749 static_cast<VkImageUsageFlags>( usage ),
12750 static_cast<VkImageCreateFlags>( flags ),
12751 static_cast<VkExternalMemoryHandleTypeFlagsNV>( externalHandleType ),
12752 reinterpret_cast<VkExternalImageFormatPropertiesNV *>( &externalImageFormatProperties ) ) );
12753 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getExternalImageFormatPropertiesNV" );
12754
12755 return detail::createResultValueType( result, std::move( externalImageFormatProperties ) );
12756 }
12757 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12758
12759 #if defined( VK_USE_PLATFORM_WIN32_KHR )
12760 //=== VK_NV_external_memory_win32 ===
12761
12762 // wrapper function for command vkGetMemoryWin32HandleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryWin32HandleNV.html
12763 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
12764 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getMemoryWin32HandleNV( DeviceMemory memory,
12765 ExternalMemoryHandleTypeFlagsNV handleType,
12766 HANDLE * pHandle,
12767 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
12768 {
12769 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
12770 return static_cast<Result>( d.vkGetMemoryWin32HandleNV(
12771 static_cast<VkDevice>( m_device ), static_cast<VkDeviceMemory>( memory ), static_cast<VkExternalMemoryHandleTypeFlagsNV>( handleType ), pHandle ) );
12772 }
12773
12774 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12775 // wrapper function for command vkGetMemoryWin32HandleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryWin32HandleNV.html
12776 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
12777 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<HANDLE>::type
12778 Device::getMemoryWin32HandleNV( DeviceMemory memory, ExternalMemoryHandleTypeFlagsNV handleType, Dispatch const & d ) const
12779 {
12780 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
12781 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
12782 VULKAN_HPP_ASSERT( d.vkGetMemoryWin32HandleNV && "Function <vkGetMemoryWin32HandleNV> requires <VK_NV_external_memory_win32>" );
12783 # endif
12784
12785 HANDLE handle;
12786 Result result = static_cast<Result>(
12787 d.vkGetMemoryWin32HandleNV( m_device, static_cast<VkDeviceMemory>( memory ), static_cast<VkExternalMemoryHandleTypeFlagsNV>( handleType ), &handle ) );
12788 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryWin32HandleNV" );
12789
12790 return detail::createResultValueType( result, std::move( handle ) );
12791 }
12792 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12793 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
12794
12795 //=== VK_KHR_get_physical_device_properties2 ===
12796
12797 // wrapper function for command vkGetPhysicalDeviceFeatures2KHR, see
12798 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures2KHR.html
12799 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
12800 VULKAN_HPP_INLINE void PhysicalDevice::getFeatures2KHR( PhysicalDeviceFeatures2 * pFeatures, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
12801 {
12802 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
12803 d.vkGetPhysicalDeviceFeatures2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), reinterpret_cast<VkPhysicalDeviceFeatures2 *>( pFeatures ) );
12804 }
12805
12806 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12807 // wrapper function for command vkGetPhysicalDeviceFeatures2KHR, see
12808 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures2KHR.html
12809 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
12810 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PhysicalDeviceFeatures2 PhysicalDevice::getFeatures2KHR( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
12811 {
12812 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
12813 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
12814 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceFeatures2KHR &&
12815 "Function <vkGetPhysicalDeviceFeatures2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
12816 # endif
12817
12818 PhysicalDeviceFeatures2 features;
12819 d.vkGetPhysicalDeviceFeatures2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2 *>( &features ) );
12820
12821 return features;
12822 }
12823
12824 // wrapper function for command vkGetPhysicalDeviceFeatures2KHR, see
12825 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures2KHR.html
12826 template <typename X, typename Y, typename... Z, typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
12827 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getFeatures2KHR( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
12828 {
12829 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
12830 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
12831 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceFeatures2KHR &&
12832 "Function <vkGetPhysicalDeviceFeatures2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
12833 # endif
12834
12835 StructureChain<X, Y, Z...> structureChain;
12836 PhysicalDeviceFeatures2 & features = structureChain.template get<PhysicalDeviceFeatures2>();
12837 d.vkGetPhysicalDeviceFeatures2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2 *>( &features ) );
12838
12839 return structureChain;
12840 }
12841 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12842
12843 // wrapper function for command vkGetPhysicalDeviceProperties2KHR, see
12844 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties2KHR.html
12845 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
12846 VULKAN_HPP_INLINE void PhysicalDevice::getProperties2KHR( PhysicalDeviceProperties2 * pProperties, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
12847 {
12848 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
12849 d.vkGetPhysicalDeviceProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), reinterpret_cast<VkPhysicalDeviceProperties2 *>( pProperties ) );
12850 }
12851
12852 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12853 // wrapper function for command vkGetPhysicalDeviceProperties2KHR, see
12854 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties2KHR.html
12855 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
12856 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PhysicalDeviceProperties2 PhysicalDevice::getProperties2KHR( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
12857 {
12858 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
12859 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
12860 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceProperties2KHR &&
12861 "Function <vkGetPhysicalDeviceProperties2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
12862 # endif
12863
12864 PhysicalDeviceProperties2 properties;
12865 d.vkGetPhysicalDeviceProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2 *>( &properties ) );
12866
12867 return properties;
12868 }
12869
12870 // wrapper function for command vkGetPhysicalDeviceProperties2KHR, see
12871 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties2KHR.html
12872 template <typename X, typename Y, typename... Z, typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
12873 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getProperties2KHR( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
12874 {
12875 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
12876 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
12877 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceProperties2KHR &&
12878 "Function <vkGetPhysicalDeviceProperties2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
12879 # endif
12880
12881 StructureChain<X, Y, Z...> structureChain;
12882 PhysicalDeviceProperties2 & properties = structureChain.template get<PhysicalDeviceProperties2>();
12883 d.vkGetPhysicalDeviceProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2 *>( &properties ) );
12884
12885 return structureChain;
12886 }
12887 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12888
12889 // wrapper function for command vkGetPhysicalDeviceFormatProperties2KHR, see
12890 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties2KHR.html
12891 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
12892 VULKAN_HPP_INLINE void
12893 PhysicalDevice::getFormatProperties2KHR( Format format, FormatProperties2 * pFormatProperties, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
12894 {
12895 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
12896 d.vkGetPhysicalDeviceFormatProperties2KHR(
12897 static_cast<VkPhysicalDevice>( m_physicalDevice ), static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2 *>( pFormatProperties ) );
12898 }
12899
12900 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12901 // wrapper function for command vkGetPhysicalDeviceFormatProperties2KHR, see
12902 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties2KHR.html
12903 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
12904 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE FormatProperties2 PhysicalDevice::getFormatProperties2KHR( Format format,
12905 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
12906 {
12907 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
12908 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
12909 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceFormatProperties2KHR &&
12910 "Function <vkGetPhysicalDeviceFormatProperties2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
12911 # endif
12912
12913 FormatProperties2 formatProperties;
12914 d.vkGetPhysicalDeviceFormatProperties2KHR(
12915 m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2 *>( &formatProperties ) );
12916
12917 return formatProperties;
12918 }
12919
12920 // wrapper function for command vkGetPhysicalDeviceFormatProperties2KHR, see
12921 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties2KHR.html
12922 template <typename X, typename Y, typename... Z, typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
12923 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getFormatProperties2KHR( Format format,
12924 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
12925 {
12926 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
12927 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
12928 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceFormatProperties2KHR &&
12929 "Function <vkGetPhysicalDeviceFormatProperties2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
12930 # endif
12931
12932 StructureChain<X, Y, Z...> structureChain;
12933 FormatProperties2 & formatProperties = structureChain.template get<FormatProperties2>();
12934 d.vkGetPhysicalDeviceFormatProperties2KHR(
12935 m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2 *>( &formatProperties ) );
12936
12937 return structureChain;
12938 }
12939 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12940
12941 // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2KHR, see
12942 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2KHR.html
12943 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
12944 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 * pImageFormatInfo,
12945 ImageFormatProperties2 * pImageFormatProperties,
12946 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
12947 {
12948 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
12949 return static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
12950 reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>( pImageFormatInfo ),
12951 reinterpret_cast<VkImageFormatProperties2 *>( pImageFormatProperties ) ) );
12952 }
12953
12954 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12955 // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2KHR, see
12956 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2KHR.html
12957 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
12958 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<ImageFormatProperties2>::type
12959 PhysicalDevice::getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const & d ) const
12960 {
12961 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
12962 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
12963 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceImageFormatProperties2KHR &&
12964 "Function <vkGetPhysicalDeviceImageFormatProperties2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
12965 # endif
12966
12967 ImageFormatProperties2 imageFormatProperties;
12968 Result result =
12969 static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2KHR( m_physicalDevice,
12970 reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>( &imageFormatInfo ),
12971 reinterpret_cast<VkImageFormatProperties2 *>( &imageFormatProperties ) ) );
12972 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2KHR" );
12973
12974 return detail::createResultValueType( result, std::move( imageFormatProperties ) );
12975 }
12976
12977 // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2KHR, see
12978 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2KHR.html
12979 template <typename X, typename Y, typename... Z, typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
12980 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<StructureChain<X, Y, Z...>>::type
12981 PhysicalDevice::getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const & d ) const
12982 {
12983 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
12984 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
12985 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceImageFormatProperties2KHR &&
12986 "Function <vkGetPhysicalDeviceImageFormatProperties2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
12987 # endif
12988
12989 StructureChain<X, Y, Z...> structureChain;
12990 ImageFormatProperties2 & imageFormatProperties = structureChain.template get<ImageFormatProperties2>();
12991 Result result =
12992 static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2KHR( m_physicalDevice,
12993 reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>( &imageFormatInfo ),
12994 reinterpret_cast<VkImageFormatProperties2 *>( &imageFormatProperties ) ) );
12995 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2KHR" );
12996
12997 return detail::createResultValueType( result, std::move( structureChain ) );
12998 }
12999 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13000
13001 // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2KHR, see
13002 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2KHR.html
13003 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
13004 VULKAN_HPP_INLINE void PhysicalDevice::getQueueFamilyProperties2KHR( uint32_t * pQueueFamilyPropertyCount,
13005 QueueFamilyProperties2 * pQueueFamilyProperties,
13006 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
13007 {
13008 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
13009 d.vkGetPhysicalDeviceQueueFamilyProperties2KHR(
13010 static_cast<VkPhysicalDevice>( m_physicalDevice ), pQueueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2 *>( pQueueFamilyProperties ) );
13011 }
13012
13013 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13014 // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2KHR, see
13015 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2KHR.html
13016 template <typename QueueFamilyProperties2Allocator,
13017 typename Dispatch,
13018 typename std::enable_if<std::is_same<typename QueueFamilyProperties2Allocator::value_type, QueueFamilyProperties2>::value, int>::type,
13019 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
13020 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator>
13021 PhysicalDevice::getQueueFamilyProperties2KHR( Dispatch const & d ) const
13022 {
13023 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
13024 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
13025 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyProperties2KHR &&
13026 "Function <vkGetPhysicalDeviceQueueFamilyProperties2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
13027 # endif
13028
13029 std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator> queueFamilyProperties;
13030 uint32_t queueFamilyPropertyCount;
13031 d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
13032 queueFamilyProperties.resize( queueFamilyPropertyCount );
13033 d.vkGetPhysicalDeviceQueueFamilyProperties2KHR(
13034 m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) );
13035
13036 VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() );
13037 if ( queueFamilyPropertyCount < queueFamilyProperties.size() )
13038 {
13039 queueFamilyProperties.resize( queueFamilyPropertyCount );
13040 }
13041 return queueFamilyProperties;
13042 }
13043
13044 // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2KHR, see
13045 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2KHR.html
13046 template <typename QueueFamilyProperties2Allocator,
13047 typename Dispatch,
13048 typename std::enable_if<std::is_same<typename QueueFamilyProperties2Allocator::value_type, QueueFamilyProperties2>::value, int>::type,
13049 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
13050 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator>
13051 PhysicalDevice::getQueueFamilyProperties2KHR( QueueFamilyProperties2Allocator & queueFamilyProperties2Allocator, Dispatch const & d ) const
13052 {
13053 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
13054 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
13055 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyProperties2KHR &&
13056 "Function <vkGetPhysicalDeviceQueueFamilyProperties2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
13057 # endif
13058
13059 std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator> queueFamilyProperties( queueFamilyProperties2Allocator );
13060 uint32_t queueFamilyPropertyCount;
13061 d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
13062 queueFamilyProperties.resize( queueFamilyPropertyCount );
13063 d.vkGetPhysicalDeviceQueueFamilyProperties2KHR(
13064 m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) );
13065
13066 VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() );
13067 if ( queueFamilyPropertyCount < queueFamilyProperties.size() )
13068 {
13069 queueFamilyProperties.resize( queueFamilyPropertyCount );
13070 }
13071 return queueFamilyProperties;
13072 }
13073
13074 // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2KHR, see
13075 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2KHR.html
13076 template <typename StructureChain,
13077 typename StructureChainAllocator,
13078 typename Dispatch,
13079 typename std::enable_if<std::is_same<typename StructureChainAllocator::value_type, StructureChain>::value, int>::type,
13080 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
13081 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<StructureChain, StructureChainAllocator>
13082 PhysicalDevice::getQueueFamilyProperties2KHR( Dispatch const & d ) const
13083 {
13084 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
13085 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
13086 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyProperties2KHR &&
13087 "Function <vkGetPhysicalDeviceQueueFamilyProperties2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
13088 # endif
13089
13090 std::vector<StructureChain, StructureChainAllocator> structureChains;
13091 std::vector<QueueFamilyProperties2> queueFamilyProperties;
13092 uint32_t queueFamilyPropertyCount;
13093 d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
13094 structureChains.resize( queueFamilyPropertyCount );
13095 queueFamilyProperties.resize( queueFamilyPropertyCount );
13096 for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ )
13097 {
13098 queueFamilyProperties[i].pNext = structureChains[i].template get<QueueFamilyProperties2>().pNext;
13099 }
13100 d.vkGetPhysicalDeviceQueueFamilyProperties2KHR(
13101 m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) );
13102
13103 VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() );
13104 if ( queueFamilyPropertyCount < queueFamilyProperties.size() )
13105 {
13106 structureChains.resize( queueFamilyPropertyCount );
13107 }
13108 for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ )
13109 {
13110 structureChains[i].template get<QueueFamilyProperties2>() = queueFamilyProperties[i];
13111 }
13112 return structureChains;
13113 }
13114
13115 // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2KHR, see
13116 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2KHR.html
13117 template <typename StructureChain,
13118 typename StructureChainAllocator,
13119 typename Dispatch,
13120 typename std::enable_if<std::is_same<typename StructureChainAllocator::value_type, StructureChain>::value, int>::type,
13121 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
13122 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<StructureChain, StructureChainAllocator>
13123 PhysicalDevice::getQueueFamilyProperties2KHR( StructureChainAllocator & structureChainAllocator, Dispatch const & d ) const
13124 {
13125 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
13126 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
13127 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyProperties2KHR &&
13128 "Function <vkGetPhysicalDeviceQueueFamilyProperties2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
13129 # endif
13130
13131 std::vector<StructureChain, StructureChainAllocator> structureChains( structureChainAllocator );
13132 std::vector<QueueFamilyProperties2> queueFamilyProperties;
13133 uint32_t queueFamilyPropertyCount;
13134 d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
13135 structureChains.resize( queueFamilyPropertyCount );
13136 queueFamilyProperties.resize( queueFamilyPropertyCount );
13137 for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ )
13138 {
13139 queueFamilyProperties[i].pNext = structureChains[i].template get<QueueFamilyProperties2>().pNext;
13140 }
13141 d.vkGetPhysicalDeviceQueueFamilyProperties2KHR(
13142 m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) );
13143
13144 VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() );
13145 if ( queueFamilyPropertyCount < queueFamilyProperties.size() )
13146 {
13147 structureChains.resize( queueFamilyPropertyCount );
13148 }
13149 for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ )
13150 {
13151 structureChains[i].template get<QueueFamilyProperties2>() = queueFamilyProperties[i];
13152 }
13153 return structureChains;
13154 }
13155 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13156
13157 // wrapper function for command vkGetPhysicalDeviceMemoryProperties2KHR, see
13158 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties2KHR.html
13159 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
13160 VULKAN_HPP_INLINE void PhysicalDevice::getMemoryProperties2KHR( PhysicalDeviceMemoryProperties2 * pMemoryProperties,
13161 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
13162 {
13163 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
13164 d.vkGetPhysicalDeviceMemoryProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
13165 reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>( pMemoryProperties ) );
13166 }
13167
13168 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13169 // wrapper function for command vkGetPhysicalDeviceMemoryProperties2KHR, see
13170 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties2KHR.html
13171 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
13172 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PhysicalDeviceMemoryProperties2 PhysicalDevice::getMemoryProperties2KHR( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
13173 {
13174 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
13175 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
13176 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceMemoryProperties2KHR &&
13177 "Function <vkGetPhysicalDeviceMemoryProperties2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
13178 # endif
13179
13180 PhysicalDeviceMemoryProperties2 memoryProperties;
13181 d.vkGetPhysicalDeviceMemoryProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>( &memoryProperties ) );
13182
13183 return memoryProperties;
13184 }
13185
13186 // wrapper function for command vkGetPhysicalDeviceMemoryProperties2KHR, see
13187 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties2KHR.html
13188 template <typename X, typename Y, typename... Z, typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
13189 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getMemoryProperties2KHR( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
13190 {
13191 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
13192 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
13193 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceMemoryProperties2KHR &&
13194 "Function <vkGetPhysicalDeviceMemoryProperties2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
13195 # endif
13196
13197 StructureChain<X, Y, Z...> structureChain;
13198 PhysicalDeviceMemoryProperties2 & memoryProperties = structureChain.template get<PhysicalDeviceMemoryProperties2>();
13199 d.vkGetPhysicalDeviceMemoryProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>( &memoryProperties ) );
13200
13201 return structureChain;
13202 }
13203 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13204
13205 // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties2KHR, see
13206 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2KHR.html
13207 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
13208 VULKAN_HPP_INLINE void PhysicalDevice::getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,
13209 uint32_t * pPropertyCount,
13210 SparseImageFormatProperties2 * pProperties,
13211 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
13212 {
13213 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
13214 d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
13215 reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( pFormatInfo ),
13216 pPropertyCount,
13217 reinterpret_cast<VkSparseImageFormatProperties2 *>( pProperties ) );
13218 }
13219
13220 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13221 // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties2KHR, see
13222 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2KHR.html
13223 template <typename SparseImageFormatProperties2Allocator,
13224 typename Dispatch,
13225 typename std::enable_if<std::is_same<typename SparseImageFormatProperties2Allocator::value_type, SparseImageFormatProperties2>::value, int>::type,
13226 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
13227 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
13228 PhysicalDevice::getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Dispatch const & d ) const
13229 {
13230 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
13231 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
13232 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR &&
13233 "Function <vkGetPhysicalDeviceSparseImageFormatProperties2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
13234 # endif
13235
13236 std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator> properties;
13237 uint32_t propertyCount;
13238 d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
13239 m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ), &propertyCount, nullptr );
13240 properties.resize( propertyCount );
13241 d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR( m_physicalDevice,
13242 reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ),
13243 &propertyCount,
13244 reinterpret_cast<VkSparseImageFormatProperties2 *>( properties.data() ) );
13245
13246 VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
13247 if ( propertyCount < properties.size() )
13248 {
13249 properties.resize( propertyCount );
13250 }
13251 return properties;
13252 }
13253
13254 // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties2KHR, see
13255 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2KHR.html
13256 template <typename SparseImageFormatProperties2Allocator,
13257 typename Dispatch,
13258 typename std::enable_if<std::is_same<typename SparseImageFormatProperties2Allocator::value_type, SparseImageFormatProperties2>::value, int>::type,
13259 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
13260 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
13261 PhysicalDevice::getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
13262 SparseImageFormatProperties2Allocator & sparseImageFormatProperties2Allocator,
13263 Dispatch const & d ) const
13264 {
13265 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
13266 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
13267 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR &&
13268 "Function <vkGetPhysicalDeviceSparseImageFormatProperties2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
13269 # endif
13270
13271 std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator> properties( sparseImageFormatProperties2Allocator );
13272 uint32_t propertyCount;
13273 d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
13274 m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ), &propertyCount, nullptr );
13275 properties.resize( propertyCount );
13276 d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR( m_physicalDevice,
13277 reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ),
13278 &propertyCount,
13279 reinterpret_cast<VkSparseImageFormatProperties2 *>( properties.data() ) );
13280
13281 VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
13282 if ( propertyCount < properties.size() )
13283 {
13284 properties.resize( propertyCount );
13285 }
13286 return properties;
13287 }
13288 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13289
13290 //=== VK_KHR_device_group ===
13291
13292 // wrapper function for command vkGetDeviceGroupPeerMemoryFeaturesKHR, see
13293 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupPeerMemoryFeaturesKHR.html
13294 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
13295 VULKAN_HPP_INLINE void Device::getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex,
13296 uint32_t localDeviceIndex,
13297 uint32_t remoteDeviceIndex,
13298 PeerMemoryFeatureFlags * pPeerMemoryFeatures,
13299 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
13300 {
13301 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
13302 d.vkGetDeviceGroupPeerMemoryFeaturesKHR(
13303 static_cast<VkDevice>( m_device ), heapIndex, localDeviceIndex, remoteDeviceIndex, reinterpret_cast<VkPeerMemoryFeatureFlags *>( pPeerMemoryFeatures ) );
13304 }
13305
13306 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13307 // wrapper function for command vkGetDeviceGroupPeerMemoryFeaturesKHR, see
13308 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupPeerMemoryFeaturesKHR.html
13309 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
13310 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PeerMemoryFeatureFlags Device::getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex,
13311 uint32_t localDeviceIndex,
13312 uint32_t remoteDeviceIndex,
13313 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
13314 {
13315 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
13316 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
13317 VULKAN_HPP_ASSERT( d.vkGetDeviceGroupPeerMemoryFeaturesKHR &&
13318 "Function <vkGetDeviceGroupPeerMemoryFeaturesKHR> requires <VK_KHR_device_group> or <VK_VERSION_1_1>" );
13319 # endif
13320
13321 PeerMemoryFeatureFlags peerMemoryFeatures;
13322 d.vkGetDeviceGroupPeerMemoryFeaturesKHR(
13323 m_device, heapIndex, localDeviceIndex, remoteDeviceIndex, reinterpret_cast<VkPeerMemoryFeatureFlags *>( &peerMemoryFeatures ) );
13324
13325 return peerMemoryFeatures;
13326 }
13327 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13328
13329 // wrapper function for command vkCmdSetDeviceMaskKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDeviceMaskKHR.html
13330 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
13331 VULKAN_HPP_INLINE void CommandBuffer::setDeviceMaskKHR( uint32_t deviceMask, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
13332 {
13333 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
13334 d.vkCmdSetDeviceMaskKHR( static_cast<VkCommandBuffer>( m_commandBuffer ), deviceMask );
13335 }
13336
13337 // wrapper function for command vkCmdDispatchBaseKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchBaseKHR.html
13338 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
13339 VULKAN_HPP_INLINE void CommandBuffer::dispatchBaseKHR( uint32_t baseGroupX,
13340 uint32_t baseGroupY,
13341 uint32_t baseGroupZ,
13342 uint32_t groupCountX,
13343 uint32_t groupCountY,
13344 uint32_t groupCountZ,
13345 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
13346 {
13347 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
13348 d.vkCmdDispatchBaseKHR( static_cast<VkCommandBuffer>( m_commandBuffer ), baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ );
13349 }
13350
13351 #if defined( VK_USE_PLATFORM_VI_NN )
13352 //=== VK_NN_vi_surface ===
13353
13354 // wrapper function for command vkCreateViSurfaceNN, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateViSurfaceNN.html
13355 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
13356 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createViSurfaceNN( const ViSurfaceCreateInfoNN * pCreateInfo,
13357 const AllocationCallbacks * pAllocator,
13358 SurfaceKHR * pSurface,
13359 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
13360 {
13361 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
13362 return static_cast<Result>( d.vkCreateViSurfaceNN( static_cast<VkInstance>( m_instance ),
13363 reinterpret_cast<const VkViSurfaceCreateInfoNN *>( pCreateInfo ),
13364 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
13365 reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) );
13366 }
13367
13368 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13369 // wrapper function for command vkCreateViSurfaceNN, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateViSurfaceNN.html
13370 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
13371 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<SurfaceKHR>::type
13372 Instance::createViSurfaceNN( const ViSurfaceCreateInfoNN & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
13373 {
13374 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
13375 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
13376 VULKAN_HPP_ASSERT( d.vkCreateViSurfaceNN && "Function <vkCreateViSurfaceNN> requires <VK_NN_vi_surface>" );
13377 # endif
13378
13379 SurfaceKHR surface;
13380 Result result = static_cast<Result>( d.vkCreateViSurfaceNN( m_instance,
13381 reinterpret_cast<const VkViSurfaceCreateInfoNN *>( &createInfo ),
13382 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
13383 reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
13384 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createViSurfaceNN" );
13385
13386 return detail::createResultValueType( result, std::move( surface ) );
13387 }
13388
13389 # ifndef VULKAN_HPP_NO_SMART_HANDLE
13390 // wrapper function for command vkCreateViSurfaceNN, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateViSurfaceNN.html
13391 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
13392 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
13393 Instance::createViSurfaceNNUnique( const ViSurfaceCreateInfoNN & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
13394 {
13395 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
13396 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
13397 VULKAN_HPP_ASSERT( d.vkCreateViSurfaceNN && "Function <vkCreateViSurfaceNN> requires <VK_NN_vi_surface>" );
13398 # endif
13399
13400 SurfaceKHR surface;
13401 Result result = static_cast<Result>( d.vkCreateViSurfaceNN( m_instance,
13402 reinterpret_cast<const VkViSurfaceCreateInfoNN *>( &createInfo ),
13403 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
13404 reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
13405 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createViSurfaceNNUnique" );
13406
13407 return detail::createResultValueType( result,
13408 UniqueHandle<SurfaceKHR, Dispatch>( surface, detail::ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) );
13409 }
13410 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
13411 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13412 #endif /*VK_USE_PLATFORM_VI_NN*/
13413
13414 //=== VK_KHR_maintenance1 ===
13415
13416 // wrapper function for command vkTrimCommandPoolKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkTrimCommandPoolKHR.html
13417 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
13418 VULKAN_HPP_INLINE void Device::trimCommandPoolKHR( CommandPool commandPool, CommandPoolTrimFlags flags, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
13419 {
13420 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
13421 d.vkTrimCommandPoolKHR( static_cast<VkDevice>( m_device ), static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolTrimFlags>( flags ) );
13422 }
13423
13424 //=== VK_KHR_device_group_creation ===
13425
13426 // wrapper function for command vkEnumeratePhysicalDeviceGroupsKHR, see
13427 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceGroupsKHR.html
13428 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
13429 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::enumeratePhysicalDeviceGroupsKHR( uint32_t * pPhysicalDeviceGroupCount,
13430 PhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties,
13431 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
13432 {
13433 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
13434 return static_cast<Result>( d.vkEnumeratePhysicalDeviceGroupsKHR( static_cast<VkInstance>( m_instance ),
13435 pPhysicalDeviceGroupCount,
13436 reinterpret_cast<VkPhysicalDeviceGroupProperties *>( pPhysicalDeviceGroupProperties ) ) );
13437 }
13438
13439 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13440 // wrapper function for command vkEnumeratePhysicalDeviceGroupsKHR, see
13441 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceGroupsKHR.html
13442 template <typename PhysicalDeviceGroupPropertiesAllocator,
13443 typename Dispatch,
13444 typename std::enable_if<std::is_same<typename PhysicalDeviceGroupPropertiesAllocator::value_type, PhysicalDeviceGroupProperties>::value, int>::type,
13445 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
13446 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type
13447 Instance::enumeratePhysicalDeviceGroupsKHR( Dispatch const & d ) const
13448 {
13449 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
13450 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
13451 VULKAN_HPP_ASSERT( d.vkEnumeratePhysicalDeviceGroupsKHR &&
13452 "Function <vkEnumeratePhysicalDeviceGroupsKHR> requires <VK_KHR_device_group_creation> or <VK_VERSION_1_1>" );
13453 # endif
13454
13455 std::vector<PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator> physicalDeviceGroupProperties;
13456 uint32_t physicalDeviceGroupCount;
13457 Result result;
13458 do
13459 {
13460 result = static_cast<Result>( d.vkEnumeratePhysicalDeviceGroupsKHR( m_instance, &physicalDeviceGroupCount, nullptr ) );
13461 if ( ( result == Result::eSuccess ) && physicalDeviceGroupCount )
13462 {
13463 physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
13464 result = static_cast<Result>( d.vkEnumeratePhysicalDeviceGroupsKHR(
13465 m_instance, &physicalDeviceGroupCount, reinterpret_cast<VkPhysicalDeviceGroupProperties *>( physicalDeviceGroupProperties.data() ) ) );
13466 }
13467 } while ( result == Result::eIncomplete );
13468 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::enumeratePhysicalDeviceGroupsKHR" );
13469 VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() );
13470 if ( physicalDeviceGroupCount < physicalDeviceGroupProperties.size() )
13471 {
13472 physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
13473 }
13474 return detail::createResultValueType( result, std::move( physicalDeviceGroupProperties ) );
13475 }
13476
13477 // wrapper function for command vkEnumeratePhysicalDeviceGroupsKHR, see
13478 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceGroupsKHR.html
13479 template <typename PhysicalDeviceGroupPropertiesAllocator,
13480 typename Dispatch,
13481 typename std::enable_if<std::is_same<typename PhysicalDeviceGroupPropertiesAllocator::value_type, PhysicalDeviceGroupProperties>::value, int>::type,
13482 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
13483 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type
13484 Instance::enumeratePhysicalDeviceGroupsKHR( PhysicalDeviceGroupPropertiesAllocator & physicalDeviceGroupPropertiesAllocator, Dispatch const & d ) const
13485 {
13486 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
13487 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
13488 VULKAN_HPP_ASSERT( d.vkEnumeratePhysicalDeviceGroupsKHR &&
13489 "Function <vkEnumeratePhysicalDeviceGroupsKHR> requires <VK_KHR_device_group_creation> or <VK_VERSION_1_1>" );
13490 # endif
13491
13492 std::vector<PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator> physicalDeviceGroupProperties( physicalDeviceGroupPropertiesAllocator );
13493 uint32_t physicalDeviceGroupCount;
13494 Result result;
13495 do
13496 {
13497 result = static_cast<Result>( d.vkEnumeratePhysicalDeviceGroupsKHR( m_instance, &physicalDeviceGroupCount, nullptr ) );
13498 if ( ( result == Result::eSuccess ) && physicalDeviceGroupCount )
13499 {
13500 physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
13501 result = static_cast<Result>( d.vkEnumeratePhysicalDeviceGroupsKHR(
13502 m_instance, &physicalDeviceGroupCount, reinterpret_cast<VkPhysicalDeviceGroupProperties *>( physicalDeviceGroupProperties.data() ) ) );
13503 }
13504 } while ( result == Result::eIncomplete );
13505 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::enumeratePhysicalDeviceGroupsKHR" );
13506 VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() );
13507 if ( physicalDeviceGroupCount < physicalDeviceGroupProperties.size() )
13508 {
13509 physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
13510 }
13511 return detail::createResultValueType( result, std::move( physicalDeviceGroupProperties ) );
13512 }
13513 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13514
13515 //=== VK_KHR_external_memory_capabilities ===
13516
13517 // wrapper function for command vkGetPhysicalDeviceExternalBufferPropertiesKHR, see
13518 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalBufferPropertiesKHR.html
13519 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
13520 VULKAN_HPP_INLINE void PhysicalDevice::getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfo * pExternalBufferInfo,
13521 ExternalBufferProperties * pExternalBufferProperties,
13522 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
13523 {
13524 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
13525 d.vkGetPhysicalDeviceExternalBufferPropertiesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
13526 reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo *>( pExternalBufferInfo ),
13527 reinterpret_cast<VkExternalBufferProperties *>( pExternalBufferProperties ) );
13528 }
13529
13530 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13531 // wrapper function for command vkGetPhysicalDeviceExternalBufferPropertiesKHR, see
13532 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalBufferPropertiesKHR.html
13533 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
13534 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ExternalBufferProperties
13535 PhysicalDevice::getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfo & externalBufferInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
13536 {
13537 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
13538 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
13539 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceExternalBufferPropertiesKHR &&
13540 "Function <vkGetPhysicalDeviceExternalBufferPropertiesKHR> requires <VK_KHR_external_memory_capabilities> or <VK_VERSION_1_1>" );
13541 # endif
13542
13543 ExternalBufferProperties externalBufferProperties;
13544 d.vkGetPhysicalDeviceExternalBufferPropertiesKHR( m_physicalDevice,
13545 reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo *>( &externalBufferInfo ),
13546 reinterpret_cast<VkExternalBufferProperties *>( &externalBufferProperties ) );
13547
13548 return externalBufferProperties;
13549 }
13550 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13551
13552 #if defined( VK_USE_PLATFORM_WIN32_KHR )
13553 //=== VK_KHR_external_memory_win32 ===
13554
13555 // wrapper function for command vkGetMemoryWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryWin32HandleKHR.html
13556 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
13557 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR * pGetWin32HandleInfo,
13558 HANDLE * pHandle,
13559 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
13560 {
13561 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
13562 return static_cast<Result>( d.vkGetMemoryWin32HandleKHR(
13563 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkMemoryGetWin32HandleInfoKHR *>( pGetWin32HandleInfo ), pHandle ) );
13564 }
13565
13566 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13567 // wrapper function for command vkGetMemoryWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryWin32HandleKHR.html
13568 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
13569 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<HANDLE>::type
13570 Device::getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const & d ) const
13571 {
13572 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
13573 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
13574 VULKAN_HPP_ASSERT( d.vkGetMemoryWin32HandleKHR && "Function <vkGetMemoryWin32HandleKHR> requires <VK_KHR_external_memory_win32>" );
13575 # endif
13576
13577 HANDLE handle;
13578 Result result =
13579 static_cast<Result>( d.vkGetMemoryWin32HandleKHR( m_device, reinterpret_cast<const VkMemoryGetWin32HandleInfoKHR *>( &getWin32HandleInfo ), &handle ) );
13580 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryWin32HandleKHR" );
13581
13582 return detail::createResultValueType( result, std::move( handle ) );
13583 }
13584 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13585
13586 // wrapper function for command vkGetMemoryWin32HandlePropertiesKHR, see
13587 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryWin32HandlePropertiesKHR.html
13588 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
13589 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getMemoryWin32HandlePropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType,
13590 HANDLE handle,
13591 MemoryWin32HandlePropertiesKHR * pMemoryWin32HandleProperties,
13592 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
13593 {
13594 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
13595 return static_cast<Result>( d.vkGetMemoryWin32HandlePropertiesKHR( static_cast<VkDevice>( m_device ),
13596 static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ),
13597 handle,
13598 reinterpret_cast<VkMemoryWin32HandlePropertiesKHR *>( pMemoryWin32HandleProperties ) ) );
13599 }
13600
13601 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13602 // wrapper function for command vkGetMemoryWin32HandlePropertiesKHR, see
13603 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryWin32HandlePropertiesKHR.html
13604 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
13605 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<MemoryWin32HandlePropertiesKHR>::type
13606 Device::getMemoryWin32HandlePropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, Dispatch const & d ) const
13607 {
13608 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
13609 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
13610 VULKAN_HPP_ASSERT( d.vkGetMemoryWin32HandlePropertiesKHR && "Function <vkGetMemoryWin32HandlePropertiesKHR> requires <VK_KHR_external_memory_win32>" );
13611 # endif
13612
13613 MemoryWin32HandlePropertiesKHR memoryWin32HandleProperties;
13614 Result result =
13615 static_cast<Result>( d.vkGetMemoryWin32HandlePropertiesKHR( m_device,
13616 static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ),
13617 handle,
13618 reinterpret_cast<VkMemoryWin32HandlePropertiesKHR *>( &memoryWin32HandleProperties ) ) );
13619 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryWin32HandlePropertiesKHR" );
13620
13621 return detail::createResultValueType( result, std::move( memoryWin32HandleProperties ) );
13622 }
13623 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13624 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
13625
13626 //=== VK_KHR_external_memory_fd ===
13627
13628 // wrapper function for command vkGetMemoryFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryFdKHR.html
13629 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
13630 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getMemoryFdKHR( const MemoryGetFdInfoKHR * pGetFdInfo,
13631 int * pFd,
13632 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
13633 {
13634 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
13635 return static_cast<Result>( d.vkGetMemoryFdKHR( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkMemoryGetFdInfoKHR *>( pGetFdInfo ), pFd ) );
13636 }
13637
13638 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13639 // wrapper function for command vkGetMemoryFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryFdKHR.html
13640 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
13641 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<int>::type Device::getMemoryFdKHR( const MemoryGetFdInfoKHR & getFdInfo,
13642 Dispatch const & d ) const
13643 {
13644 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
13645 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
13646 VULKAN_HPP_ASSERT( d.vkGetMemoryFdKHR && "Function <vkGetMemoryFdKHR> requires <VK_KHR_external_memory_fd>" );
13647 # endif
13648
13649 int fd;
13650 Result result = static_cast<Result>( d.vkGetMemoryFdKHR( m_device, reinterpret_cast<const VkMemoryGetFdInfoKHR *>( &getFdInfo ), &fd ) );
13651 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryFdKHR" );
13652
13653 return detail::createResultValueType( result, std::move( fd ) );
13654 }
13655 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13656
13657 // wrapper function for command vkGetMemoryFdPropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryFdPropertiesKHR.html
13658 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
13659 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getMemoryFdPropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType,
13660 int fd,
13661 MemoryFdPropertiesKHR * pMemoryFdProperties,
13662 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
13663 {
13664 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
13665 return static_cast<Result>( d.vkGetMemoryFdPropertiesKHR( static_cast<VkDevice>( m_device ),
13666 static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ),
13667 fd,
13668 reinterpret_cast<VkMemoryFdPropertiesKHR *>( pMemoryFdProperties ) ) );
13669 }
13670
13671 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13672 // wrapper function for command vkGetMemoryFdPropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryFdPropertiesKHR.html
13673 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
13674 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<MemoryFdPropertiesKHR>::type
13675 Device::getMemoryFdPropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, int fd, Dispatch const & d ) const
13676 {
13677 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
13678 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
13679 VULKAN_HPP_ASSERT( d.vkGetMemoryFdPropertiesKHR && "Function <vkGetMemoryFdPropertiesKHR> requires <VK_KHR_external_memory_fd>" );
13680 # endif
13681
13682 MemoryFdPropertiesKHR memoryFdProperties;
13683 Result result = static_cast<Result>( d.vkGetMemoryFdPropertiesKHR(
13684 m_device, static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ), fd, reinterpret_cast<VkMemoryFdPropertiesKHR *>( &memoryFdProperties ) ) );
13685 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryFdPropertiesKHR" );
13686
13687 return detail::createResultValueType( result, std::move( memoryFdProperties ) );
13688 }
13689 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13690
13691 //=== VK_KHR_external_semaphore_capabilities ===
13692
13693 // wrapper function for command vkGetPhysicalDeviceExternalSemaphorePropertiesKHR, see
13694 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalSemaphorePropertiesKHR.html
13695 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
13696 VULKAN_HPP_INLINE void PhysicalDevice::getExternalSemaphorePropertiesKHR( const PhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,
13697 ExternalSemaphoreProperties * pExternalSemaphoreProperties,
13698 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
13699 {
13700 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
13701 d.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
13702 reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo *>( pExternalSemaphoreInfo ),
13703 reinterpret_cast<VkExternalSemaphoreProperties *>( pExternalSemaphoreProperties ) );
13704 }
13705
13706 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13707 // wrapper function for command vkGetPhysicalDeviceExternalSemaphorePropertiesKHR, see
13708 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalSemaphorePropertiesKHR.html
13709 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
13710 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ExternalSemaphoreProperties PhysicalDevice::getExternalSemaphorePropertiesKHR(
13711 const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
13712 {
13713 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
13714 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
13715 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR &&
13716 "Function <vkGetPhysicalDeviceExternalSemaphorePropertiesKHR> requires <VK_KHR_external_semaphore_capabilities> or <VK_VERSION_1_1>" );
13717 # endif
13718
13719 ExternalSemaphoreProperties externalSemaphoreProperties;
13720 d.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( m_physicalDevice,
13721 reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo *>( &externalSemaphoreInfo ),
13722 reinterpret_cast<VkExternalSemaphoreProperties *>( &externalSemaphoreProperties ) );
13723
13724 return externalSemaphoreProperties;
13725 }
13726 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13727
13728 #if defined( VK_USE_PLATFORM_WIN32_KHR )
13729 //=== VK_KHR_external_semaphore_win32 ===
13730
13731 // wrapper function for command vkImportSemaphoreWin32HandleKHR, see
13732 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportSemaphoreWin32HandleKHR.html
13733 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
13734 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::importSemaphoreWin32HandleKHR(
13735 const ImportSemaphoreWin32HandleInfoKHR * pImportSemaphoreWin32HandleInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
13736 {
13737 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
13738 return static_cast<Result>( d.vkImportSemaphoreWin32HandleKHR(
13739 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkImportSemaphoreWin32HandleInfoKHR *>( pImportSemaphoreWin32HandleInfo ) ) );
13740 }
13741
13742 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13743 // wrapper function for command vkImportSemaphoreWin32HandleKHR, see
13744 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportSemaphoreWin32HandleKHR.html
13745 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
13746 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
13747 Device::importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo, Dispatch const & d ) const
13748 {
13749 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
13750 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
13751 VULKAN_HPP_ASSERT( d.vkImportSemaphoreWin32HandleKHR && "Function <vkImportSemaphoreWin32HandleKHR> requires <VK_KHR_external_semaphore_win32>" );
13752 # endif
13753
13754 Result result = static_cast<Result>(
13755 d.vkImportSemaphoreWin32HandleKHR( m_device, reinterpret_cast<const VkImportSemaphoreWin32HandleInfoKHR *>( &importSemaphoreWin32HandleInfo ) ) );
13756 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::importSemaphoreWin32HandleKHR" );
13757
13758 return detail::createResultValueType( result );
13759 }
13760 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13761
13762 // wrapper function for command vkGetSemaphoreWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreWin32HandleKHR.html
13763 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
13764 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR * pGetWin32HandleInfo,
13765 HANDLE * pHandle,
13766 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
13767 {
13768 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
13769 return static_cast<Result>( d.vkGetSemaphoreWin32HandleKHR(
13770 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkSemaphoreGetWin32HandleInfoKHR *>( pGetWin32HandleInfo ), pHandle ) );
13771 }
13772
13773 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13774 // wrapper function for command vkGetSemaphoreWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreWin32HandleKHR.html
13775 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
13776 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<HANDLE>::type
13777 Device::getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const & d ) const
13778 {
13779 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
13780 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
13781 VULKAN_HPP_ASSERT( d.vkGetSemaphoreWin32HandleKHR && "Function <vkGetSemaphoreWin32HandleKHR> requires <VK_KHR_external_semaphore_win32>" );
13782 # endif
13783
13784 HANDLE handle;
13785 Result result = static_cast<Result>(
13786 d.vkGetSemaphoreWin32HandleKHR( m_device, reinterpret_cast<const VkSemaphoreGetWin32HandleInfoKHR *>( &getWin32HandleInfo ), &handle ) );
13787 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreWin32HandleKHR" );
13788
13789 return detail::createResultValueType( result, std::move( handle ) );
13790 }
13791 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13792 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
13793
13794 //=== VK_KHR_external_semaphore_fd ===
13795
13796 // wrapper function for command vkImportSemaphoreFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportSemaphoreFdKHR.html
13797 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
13798 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR * pImportSemaphoreFdInfo,
13799 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
13800 {
13801 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
13802 return static_cast<Result>(
13803 d.vkImportSemaphoreFdKHR( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkImportSemaphoreFdInfoKHR *>( pImportSemaphoreFdInfo ) ) );
13804 }
13805
13806 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13807 // wrapper function for command vkImportSemaphoreFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportSemaphoreFdKHR.html
13808 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
13809 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
13810 Device::importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR & importSemaphoreFdInfo, Dispatch const & d ) const
13811 {
13812 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
13813 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
13814 VULKAN_HPP_ASSERT( d.vkImportSemaphoreFdKHR && "Function <vkImportSemaphoreFdKHR> requires <VK_KHR_external_semaphore_fd>" );
13815 # endif
13816
13817 Result result = static_cast<Result>( d.vkImportSemaphoreFdKHR( m_device, reinterpret_cast<const VkImportSemaphoreFdInfoKHR *>( &importSemaphoreFdInfo ) ) );
13818 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::importSemaphoreFdKHR" );
13819
13820 return detail::createResultValueType( result );
13821 }
13822 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13823
13824 // wrapper function for command vkGetSemaphoreFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreFdKHR.html
13825 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
13826 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR * pGetFdInfo,
13827 int * pFd,
13828 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
13829 {
13830 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
13831 return static_cast<Result>(
13832 d.vkGetSemaphoreFdKHR( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkSemaphoreGetFdInfoKHR *>( pGetFdInfo ), pFd ) );
13833 }
13834
13835 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13836 // wrapper function for command vkGetSemaphoreFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreFdKHR.html
13837 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
13838 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<int>::type Device::getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR & getFdInfo,
13839 Dispatch const & d ) const
13840 {
13841 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
13842 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
13843 VULKAN_HPP_ASSERT( d.vkGetSemaphoreFdKHR && "Function <vkGetSemaphoreFdKHR> requires <VK_KHR_external_semaphore_fd>" );
13844 # endif
13845
13846 int fd;
13847 Result result = static_cast<Result>( d.vkGetSemaphoreFdKHR( m_device, reinterpret_cast<const VkSemaphoreGetFdInfoKHR *>( &getFdInfo ), &fd ) );
13848 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreFdKHR" );
13849
13850 return detail::createResultValueType( result, std::move( fd ) );
13851 }
13852 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13853
13854 //=== VK_KHR_push_descriptor ===
13855
13856 // wrapper function for command vkCmdPushDescriptorSetKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetKHR.html
13857 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
13858 VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetKHR( PipelineBindPoint pipelineBindPoint,
13859 PipelineLayout layout,
13860 uint32_t set,
13861 uint32_t descriptorWriteCount,
13862 const WriteDescriptorSet * pDescriptorWrites,
13863 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
13864 {
13865 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
13866 d.vkCmdPushDescriptorSetKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
13867 static_cast<VkPipelineBindPoint>( pipelineBindPoint ),
13868 static_cast<VkPipelineLayout>( layout ),
13869 set,
13870 descriptorWriteCount,
13871 reinterpret_cast<const VkWriteDescriptorSet *>( pDescriptorWrites ) );
13872 }
13873
13874 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13875 // wrapper function for command vkCmdPushDescriptorSetKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetKHR.html
13876 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
13877 VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetKHR( PipelineBindPoint pipelineBindPoint,
13878 PipelineLayout layout,
13879 uint32_t set,
13880 ArrayProxy<const WriteDescriptorSet> const & descriptorWrites,
13881 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
13882 {
13883 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
13884 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
13885 VULKAN_HPP_ASSERT( d.vkCmdPushDescriptorSetKHR && "Function <vkCmdPushDescriptorSetKHR> requires <VK_KHR_push_descriptor> or <VK_VERSION_1_4>" );
13886 # endif
13887
13888 d.vkCmdPushDescriptorSetKHR( m_commandBuffer,
13889 static_cast<VkPipelineBindPoint>( pipelineBindPoint ),
13890 static_cast<VkPipelineLayout>( layout ),
13891 set,
13892 descriptorWrites.size(),
13893 reinterpret_cast<const VkWriteDescriptorSet *>( descriptorWrites.data() ) );
13894 }
13895 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13896
13897 // wrapper function for command vkCmdPushDescriptorSetWithTemplateKHR, see
13898 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplateKHR.html
13899 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
13900 VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplateKHR(
13901 DescriptorUpdateTemplate descriptorUpdateTemplate, PipelineLayout layout, uint32_t set, const void * pData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
13902 {
13903 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
13904 d.vkCmdPushDescriptorSetWithTemplateKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
13905 static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
13906 static_cast<VkPipelineLayout>( layout ),
13907 set,
13908 pData );
13909 }
13910
13911 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13912 // wrapper function for command vkCmdPushDescriptorSetWithTemplateKHR, see
13913 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplateKHR.html
13914 template <typename DataType, typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
13915 VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate,
13916 PipelineLayout layout,
13917 uint32_t set,
13918 DataType const & data,
13919 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
13920 {
13921 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
13922 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
13923 VULKAN_HPP_ASSERT(
13924 d.vkCmdPushDescriptorSetWithTemplateKHR &&
13925 "Function <vkCmdPushDescriptorSetWithTemplateKHR> requires <VK_KHR_descriptor_update_template> or <VK_KHR_push_descriptor> or <VK_VERSION_1_4>" );
13926 # endif
13927
13928 d.vkCmdPushDescriptorSetWithTemplateKHR( m_commandBuffer,
13929 static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
13930 static_cast<VkPipelineLayout>( layout ),
13931 set,
13932 reinterpret_cast<const void *>( &data ) );
13933 }
13934 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13935
13936 //=== VK_EXT_conditional_rendering ===
13937
13938 // wrapper function for command vkCmdBeginConditionalRenderingEXT, see
13939 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginConditionalRenderingEXT.html
13940 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
13941 VULKAN_HPP_INLINE void CommandBuffer::beginConditionalRenderingEXT( const ConditionalRenderingBeginInfoEXT * pConditionalRenderingBegin,
13942 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
13943 {
13944 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
13945 d.vkCmdBeginConditionalRenderingEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
13946 reinterpret_cast<const VkConditionalRenderingBeginInfoEXT *>( pConditionalRenderingBegin ) );
13947 }
13948
13949 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13950 // wrapper function for command vkCmdBeginConditionalRenderingEXT, see
13951 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginConditionalRenderingEXT.html
13952 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
13953 VULKAN_HPP_INLINE void CommandBuffer::beginConditionalRenderingEXT( const ConditionalRenderingBeginInfoEXT & conditionalRenderingBegin,
13954 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
13955 {
13956 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
13957 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
13958 VULKAN_HPP_ASSERT( d.vkCmdBeginConditionalRenderingEXT && "Function <vkCmdBeginConditionalRenderingEXT> requires <VK_EXT_conditional_rendering>" );
13959 # endif
13960
13961 d.vkCmdBeginConditionalRenderingEXT( m_commandBuffer, reinterpret_cast<const VkConditionalRenderingBeginInfoEXT *>( &conditionalRenderingBegin ) );
13962 }
13963 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13964
13965 // wrapper function for command vkCmdEndConditionalRenderingEXT, see
13966 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndConditionalRenderingEXT.html
13967 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
13968 VULKAN_HPP_INLINE void CommandBuffer::endConditionalRenderingEXT( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
13969 {
13970 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
13971 d.vkCmdEndConditionalRenderingEXT( static_cast<VkCommandBuffer>( m_commandBuffer ) );
13972 }
13973
13974 //=== VK_KHR_descriptor_update_template ===
13975
13976 // wrapper function for command vkCreateDescriptorUpdateTemplateKHR, see
13977 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorUpdateTemplateKHR.html
13978 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
13979 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createDescriptorUpdateTemplateKHR( const DescriptorUpdateTemplateCreateInfo * pCreateInfo,
13980 const AllocationCallbacks * pAllocator,
13981 DescriptorUpdateTemplate * pDescriptorUpdateTemplate,
13982 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
13983 {
13984 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
13985 return static_cast<Result>( d.vkCreateDescriptorUpdateTemplateKHR( static_cast<VkDevice>( m_device ),
13986 reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo *>( pCreateInfo ),
13987 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
13988 reinterpret_cast<VkDescriptorUpdateTemplate *>( pDescriptorUpdateTemplate ) ) );
13989 }
13990
13991 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13992 // wrapper function for command vkCreateDescriptorUpdateTemplateKHR, see
13993 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorUpdateTemplateKHR.html
13994 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
13995 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<DescriptorUpdateTemplate>::type Device::createDescriptorUpdateTemplateKHR(
13996 const DescriptorUpdateTemplateCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
13997 {
13998 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
13999 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
14000 VULKAN_HPP_ASSERT( d.vkCreateDescriptorUpdateTemplateKHR &&
14001 "Function <vkCreateDescriptorUpdateTemplateKHR> requires <VK_KHR_descriptor_update_template> or <VK_VERSION_1_1>" );
14002 # endif
14003
14004 DescriptorUpdateTemplate descriptorUpdateTemplate;
14005 Result result = static_cast<Result>( d.vkCreateDescriptorUpdateTemplateKHR( m_device,
14006 reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo *>( &createInfo ),
14007 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
14008 reinterpret_cast<VkDescriptorUpdateTemplate *>( &descriptorUpdateTemplate ) ) );
14009 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorUpdateTemplateKHR" );
14010
14011 return detail::createResultValueType( result, std::move( descriptorUpdateTemplate ) );
14012 }
14013
14014 # ifndef VULKAN_HPP_NO_SMART_HANDLE
14015 // wrapper function for command vkCreateDescriptorUpdateTemplateKHR, see
14016 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorUpdateTemplateKHR.html
14017 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
14018 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<DescriptorUpdateTemplate, Dispatch>>::type
14019 Device::createDescriptorUpdateTemplateKHRUnique( const DescriptorUpdateTemplateCreateInfo & createInfo,
14020 Optional<const AllocationCallbacks> allocator,
14021 Dispatch const & d ) const
14022 {
14023 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
14024 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
14025 VULKAN_HPP_ASSERT( d.vkCreateDescriptorUpdateTemplateKHR &&
14026 "Function <vkCreateDescriptorUpdateTemplateKHR> requires <VK_KHR_descriptor_update_template> or <VK_VERSION_1_1>" );
14027 # endif
14028
14029 DescriptorUpdateTemplate descriptorUpdateTemplate;
14030 Result result = static_cast<Result>( d.vkCreateDescriptorUpdateTemplateKHR( m_device,
14031 reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo *>( &createInfo ),
14032 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
14033 reinterpret_cast<VkDescriptorUpdateTemplate *>( &descriptorUpdateTemplate ) ) );
14034 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorUpdateTemplateKHRUnique" );
14035
14036 return detail::createResultValueType(
14037 result, UniqueHandle<DescriptorUpdateTemplate, Dispatch>( descriptorUpdateTemplate, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
14038 }
14039 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
14040 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14041
14042 // wrapper function for command vkDestroyDescriptorUpdateTemplateKHR, see
14043 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorUpdateTemplateKHR.html
14044 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
14045 VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate,
14046 const AllocationCallbacks * pAllocator,
14047 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
14048 {
14049 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
14050 d.vkDestroyDescriptorUpdateTemplateKHR( static_cast<VkDevice>( m_device ),
14051 static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
14052 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
14053 }
14054
14055 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14056 // wrapper function for command vkDestroyDescriptorUpdateTemplateKHR, see
14057 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorUpdateTemplateKHR.html
14058 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
14059 VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate,
14060 Optional<const AllocationCallbacks> allocator,
14061 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
14062 {
14063 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
14064 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
14065 VULKAN_HPP_ASSERT( d.vkDestroyDescriptorUpdateTemplateKHR &&
14066 "Function <vkDestroyDescriptorUpdateTemplateKHR> requires <VK_KHR_descriptor_update_template> or <VK_VERSION_1_1>" );
14067 # endif
14068
14069 d.vkDestroyDescriptorUpdateTemplateKHR(
14070 m_device, static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
14071 }
14072 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14073
14074 // wrapper function for command vkUpdateDescriptorSetWithTemplateKHR, see
14075 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateDescriptorSetWithTemplateKHR.html
14076 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
14077 VULKAN_HPP_INLINE void Device::updateDescriptorSetWithTemplateKHR( DescriptorSet descriptorSet,
14078 DescriptorUpdateTemplate descriptorUpdateTemplate,
14079 const void * pData,
14080 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
14081 {
14082 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
14083 d.vkUpdateDescriptorSetWithTemplateKHR( static_cast<VkDevice>( m_device ),
14084 static_cast<VkDescriptorSet>( descriptorSet ),
14085 static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
14086 pData );
14087 }
14088
14089 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14090 // wrapper function for command vkUpdateDescriptorSetWithTemplateKHR, see
14091 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateDescriptorSetWithTemplateKHR.html
14092 template <typename DataType, typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
14093 VULKAN_HPP_INLINE void Device::updateDescriptorSetWithTemplateKHR( DescriptorSet descriptorSet,
14094 DescriptorUpdateTemplate descriptorUpdateTemplate,
14095 DataType const & data,
14096 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
14097 {
14098 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
14099 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
14100 VULKAN_HPP_ASSERT( d.vkUpdateDescriptorSetWithTemplateKHR &&
14101 "Function <vkUpdateDescriptorSetWithTemplateKHR> requires <VK_KHR_descriptor_update_template> or <VK_VERSION_1_1>" );
14102 # endif
14103
14104 d.vkUpdateDescriptorSetWithTemplateKHR( m_device,
14105 static_cast<VkDescriptorSet>( descriptorSet ),
14106 static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
14107 reinterpret_cast<const void *>( &data ) );
14108 }
14109 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14110
14111 //=== VK_NV_clip_space_w_scaling ===
14112
14113 // wrapper function for command vkCmdSetViewportWScalingNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWScalingNV.html
14114 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
14115 VULKAN_HPP_INLINE void CommandBuffer::setViewportWScalingNV( uint32_t firstViewport,
14116 uint32_t viewportCount,
14117 const ViewportWScalingNV * pViewportWScalings,
14118 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
14119 {
14120 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
14121 d.vkCmdSetViewportWScalingNV(
14122 static_cast<VkCommandBuffer>( m_commandBuffer ), firstViewport, viewportCount, reinterpret_cast<const VkViewportWScalingNV *>( pViewportWScalings ) );
14123 }
14124
14125 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14126 // wrapper function for command vkCmdSetViewportWScalingNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWScalingNV.html
14127 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
14128 VULKAN_HPP_INLINE void CommandBuffer::setViewportWScalingNV( uint32_t firstViewport,
14129 ArrayProxy<const ViewportWScalingNV> const & viewportWScalings,
14130 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
14131 {
14132 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
14133 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
14134 VULKAN_HPP_ASSERT( d.vkCmdSetViewportWScalingNV && "Function <vkCmdSetViewportWScalingNV> requires <VK_NV_clip_space_w_scaling>" );
14135 # endif
14136
14137 d.vkCmdSetViewportWScalingNV(
14138 m_commandBuffer, firstViewport, viewportWScalings.size(), reinterpret_cast<const VkViewportWScalingNV *>( viewportWScalings.data() ) );
14139 }
14140 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14141
14142 //=== VK_EXT_direct_mode_display ===
14143
14144 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
14145 // wrapper function for command vkReleaseDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseDisplayEXT.html
14146 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
14147 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::releaseDisplayEXT( DisplayKHR display, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
14148 {
14149 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
14150 return static_cast<Result>( d.vkReleaseDisplayEXT( static_cast<VkPhysicalDevice>( m_physicalDevice ), static_cast<VkDisplayKHR>( display ) ) );
14151 }
14152 #else
14153 // wrapper function for command vkReleaseDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseDisplayEXT.html
14154 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
14155 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type PhysicalDevice::releaseDisplayEXT( DisplayKHR display,
14156 Dispatch const & d ) const
14157 {
14158 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
14159 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
14160 VULKAN_HPP_ASSERT( d.vkReleaseDisplayEXT && "Function <vkReleaseDisplayEXT> requires <VK_EXT_direct_mode_display>" );
14161 # endif
14162
14163 Result result = static_cast<Result>( d.vkReleaseDisplayEXT( m_physicalDevice, static_cast<VkDisplayKHR>( display ) ) );
14164 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::releaseDisplayEXT" );
14165
14166 return detail::createResultValueType( result );
14167 }
14168 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
14169
14170 #if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT )
14171 //=== VK_EXT_acquire_xlib_display ===
14172
14173 // wrapper function for command vkAcquireXlibDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireXlibDisplayEXT.html
14174 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
14175 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::acquireXlibDisplayEXT( Display * dpy,
14176 DisplayKHR display,
14177 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
14178 {
14179 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
14180 return static_cast<Result>( d.vkAcquireXlibDisplayEXT( static_cast<VkPhysicalDevice>( m_physicalDevice ), dpy, static_cast<VkDisplayKHR>( display ) ) );
14181 }
14182
14183 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14184 // wrapper function for command vkAcquireXlibDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireXlibDisplayEXT.html
14185 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
14186 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
14187 PhysicalDevice::acquireXlibDisplayEXT( Display & dpy, DisplayKHR display, Dispatch const & d ) const
14188 {
14189 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
14190 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
14191 VULKAN_HPP_ASSERT( d.vkAcquireXlibDisplayEXT && "Function <vkAcquireXlibDisplayEXT> requires <VK_EXT_acquire_xlib_display>" );
14192 # endif
14193
14194 Result result = static_cast<Result>( d.vkAcquireXlibDisplayEXT( m_physicalDevice, &dpy, static_cast<VkDisplayKHR>( display ) ) );
14195 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::acquireXlibDisplayEXT" );
14196
14197 return detail::createResultValueType( result );
14198 }
14199 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14200
14201 // wrapper function for command vkGetRandROutputDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRandROutputDisplayEXT.html
14202 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
14203 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
14204 PhysicalDevice::getRandROutputDisplayEXT( Display * dpy, RROutput rrOutput, DisplayKHR * pDisplay, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
14205 {
14206 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
14207 return static_cast<Result>(
14208 d.vkGetRandROutputDisplayEXT( static_cast<VkPhysicalDevice>( m_physicalDevice ), dpy, rrOutput, reinterpret_cast<VkDisplayKHR *>( pDisplay ) ) );
14209 }
14210
14211 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14212 // wrapper function for command vkGetRandROutputDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRandROutputDisplayEXT.html
14213 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
14214 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<DisplayKHR>::type
14215 PhysicalDevice::getRandROutputDisplayEXT( Display & dpy, RROutput rrOutput, Dispatch const & d ) const
14216 {
14217 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
14218 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
14219 VULKAN_HPP_ASSERT( d.vkGetRandROutputDisplayEXT && "Function <vkGetRandROutputDisplayEXT> requires <VK_EXT_acquire_xlib_display>" );
14220 # endif
14221
14222 DisplayKHR display;
14223 Result result = static_cast<Result>( d.vkGetRandROutputDisplayEXT( m_physicalDevice, &dpy, rrOutput, reinterpret_cast<VkDisplayKHR *>( &display ) ) );
14224 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getRandROutputDisplayEXT" );
14225
14226 return detail::createResultValueType( result, std::move( display ) );
14227 }
14228
14229 # ifndef VULKAN_HPP_NO_SMART_HANDLE
14230 // wrapper function for command vkGetRandROutputDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRandROutputDisplayEXT.html
14231 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
14232 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<DisplayKHR, Dispatch>>::type
14233 PhysicalDevice::getRandROutputDisplayEXTUnique( Display & dpy, RROutput rrOutput, Dispatch const & d ) const
14234 {
14235 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
14236 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
14237 VULKAN_HPP_ASSERT( d.vkGetRandROutputDisplayEXT && "Function <vkGetRandROutputDisplayEXT> requires <VK_EXT_acquire_xlib_display>" );
14238 # endif
14239
14240 DisplayKHR display;
14241 Result result = static_cast<Result>( d.vkGetRandROutputDisplayEXT( m_physicalDevice, &dpy, rrOutput, reinterpret_cast<VkDisplayKHR *>( &display ) ) );
14242 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getRandROutputDisplayEXTUnique" );
14243
14244 return detail::createResultValueType( result, UniqueHandle<DisplayKHR, Dispatch>( display, detail::ObjectRelease<PhysicalDevice, Dispatch>( *this, d ) ) );
14245 }
14246 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
14247 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14248 #endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
14249
14250 //=== VK_EXT_display_surface_counter ===
14251
14252 // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilities2EXT, see
14253 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilities2EXT.html
14254 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
14255 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceCapabilities2EXT( SurfaceKHR surface,
14256 SurfaceCapabilities2EXT * pSurfaceCapabilities,
14257 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
14258 {
14259 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
14260 return static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilities2EXT( static_cast<VkPhysicalDevice>( m_physicalDevice ),
14261 static_cast<VkSurfaceKHR>( surface ),
14262 reinterpret_cast<VkSurfaceCapabilities2EXT *>( pSurfaceCapabilities ) ) );
14263 }
14264
14265 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14266 // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilities2EXT, see
14267 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilities2EXT.html
14268 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
14269 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<SurfaceCapabilities2EXT>::type
14270 PhysicalDevice::getSurfaceCapabilities2EXT( SurfaceKHR surface, Dispatch const & d ) const
14271 {
14272 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
14273 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
14274 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfaceCapabilities2EXT &&
14275 "Function <vkGetPhysicalDeviceSurfaceCapabilities2EXT> requires <VK_EXT_display_surface_counter>" );
14276 # endif
14277
14278 SurfaceCapabilities2EXT surfaceCapabilities;
14279 Result result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilities2EXT(
14280 m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkSurfaceCapabilities2EXT *>( &surfaceCapabilities ) ) );
14281 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilities2EXT" );
14282
14283 return detail::createResultValueType( result, std::move( surfaceCapabilities ) );
14284 }
14285 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14286
14287 //=== VK_EXT_display_control ===
14288
14289 // wrapper function for command vkDisplayPowerControlEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDisplayPowerControlEXT.html
14290 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
14291 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::displayPowerControlEXT( DisplayKHR display,
14292 const DisplayPowerInfoEXT * pDisplayPowerInfo,
14293 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
14294 {
14295 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
14296 return static_cast<Result>( d.vkDisplayPowerControlEXT(
14297 static_cast<VkDevice>( m_device ), static_cast<VkDisplayKHR>( display ), reinterpret_cast<const VkDisplayPowerInfoEXT *>( pDisplayPowerInfo ) ) );
14298 }
14299
14300 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14301 // wrapper function for command vkDisplayPowerControlEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDisplayPowerControlEXT.html
14302 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
14303 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
14304 Device::displayPowerControlEXT( DisplayKHR display, const DisplayPowerInfoEXT & displayPowerInfo, Dispatch const & d ) const
14305 {
14306 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
14307 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
14308 VULKAN_HPP_ASSERT( d.vkDisplayPowerControlEXT && "Function <vkDisplayPowerControlEXT> requires <VK_EXT_display_control>" );
14309 # endif
14310
14311 Result result = static_cast<Result>(
14312 d.vkDisplayPowerControlEXT( m_device, static_cast<VkDisplayKHR>( display ), reinterpret_cast<const VkDisplayPowerInfoEXT *>( &displayPowerInfo ) ) );
14313 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::displayPowerControlEXT" );
14314
14315 return detail::createResultValueType( result );
14316 }
14317 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14318
14319 // wrapper function for command vkRegisterDeviceEventEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterDeviceEventEXT.html
14320 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
14321 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::registerEventEXT( const DeviceEventInfoEXT * pDeviceEventInfo,
14322 const AllocationCallbacks * pAllocator,
14323 Fence * pFence,
14324 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
14325 {
14326 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
14327 return static_cast<Result>( d.vkRegisterDeviceEventEXT( static_cast<VkDevice>( m_device ),
14328 reinterpret_cast<const VkDeviceEventInfoEXT *>( pDeviceEventInfo ),
14329 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
14330 reinterpret_cast<VkFence *>( pFence ) ) );
14331 }
14332
14333 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14334 // wrapper function for command vkRegisterDeviceEventEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterDeviceEventEXT.html
14335 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
14336 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<Fence>::type
14337 Device::registerEventEXT( const DeviceEventInfoEXT & deviceEventInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
14338 {
14339 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
14340 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
14341 VULKAN_HPP_ASSERT( d.vkRegisterDeviceEventEXT && "Function <vkRegisterDeviceEventEXT> requires <VK_EXT_display_control>" );
14342 # endif
14343
14344 Fence fence;
14345 Result result = static_cast<Result>( d.vkRegisterDeviceEventEXT( m_device,
14346 reinterpret_cast<const VkDeviceEventInfoEXT *>( &deviceEventInfo ),
14347 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
14348 reinterpret_cast<VkFence *>( &fence ) ) );
14349 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::registerEventEXT" );
14350
14351 return detail::createResultValueType( result, std::move( fence ) );
14352 }
14353
14354 # ifndef VULKAN_HPP_NO_SMART_HANDLE
14355 // wrapper function for command vkRegisterDeviceEventEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterDeviceEventEXT.html
14356 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
14357 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Fence, Dispatch>>::type
14358 Device::registerEventEXTUnique( const DeviceEventInfoEXT & deviceEventInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
14359 {
14360 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
14361 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
14362 VULKAN_HPP_ASSERT( d.vkRegisterDeviceEventEXT && "Function <vkRegisterDeviceEventEXT> requires <VK_EXT_display_control>" );
14363 # endif
14364
14365 Fence fence;
14366 Result result = static_cast<Result>( d.vkRegisterDeviceEventEXT( m_device,
14367 reinterpret_cast<const VkDeviceEventInfoEXT *>( &deviceEventInfo ),
14368 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
14369 reinterpret_cast<VkFence *>( &fence ) ) );
14370 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::registerEventEXTUnique" );
14371
14372 return detail::createResultValueType( result, UniqueHandle<Fence, Dispatch>( fence, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
14373 }
14374 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
14375 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14376
14377 // wrapper function for command vkRegisterDisplayEventEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterDisplayEventEXT.html
14378 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
14379 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::registerDisplayEventEXT( DisplayKHR display,
14380 const DisplayEventInfoEXT * pDisplayEventInfo,
14381 const AllocationCallbacks * pAllocator,
14382 Fence * pFence,
14383 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
14384 {
14385 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
14386 return static_cast<Result>( d.vkRegisterDisplayEventEXT( static_cast<VkDevice>( m_device ),
14387 static_cast<VkDisplayKHR>( display ),
14388 reinterpret_cast<const VkDisplayEventInfoEXT *>( pDisplayEventInfo ),
14389 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
14390 reinterpret_cast<VkFence *>( pFence ) ) );
14391 }
14392
14393 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14394 // wrapper function for command vkRegisterDisplayEventEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterDisplayEventEXT.html
14395 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
14396 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<Fence>::type Device::registerDisplayEventEXT( DisplayKHR display,
14397 const DisplayEventInfoEXT & displayEventInfo,
14398 Optional<const AllocationCallbacks> allocator,
14399 Dispatch const & d ) const
14400 {
14401 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
14402 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
14403 VULKAN_HPP_ASSERT( d.vkRegisterDisplayEventEXT && "Function <vkRegisterDisplayEventEXT> requires <VK_EXT_display_control>" );
14404 # endif
14405
14406 Fence fence;
14407 Result result = static_cast<Result>( d.vkRegisterDisplayEventEXT( m_device,
14408 static_cast<VkDisplayKHR>( display ),
14409 reinterpret_cast<const VkDisplayEventInfoEXT *>( &displayEventInfo ),
14410 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
14411 reinterpret_cast<VkFence *>( &fence ) ) );
14412 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::registerDisplayEventEXT" );
14413
14414 return detail::createResultValueType( result, std::move( fence ) );
14415 }
14416
14417 # ifndef VULKAN_HPP_NO_SMART_HANDLE
14418 // wrapper function for command vkRegisterDisplayEventEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterDisplayEventEXT.html
14419 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
14420 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Fence, Dispatch>>::type Device::registerDisplayEventEXTUnique(
14421 DisplayKHR display, const DisplayEventInfoEXT & displayEventInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
14422 {
14423 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
14424 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
14425 VULKAN_HPP_ASSERT( d.vkRegisterDisplayEventEXT && "Function <vkRegisterDisplayEventEXT> requires <VK_EXT_display_control>" );
14426 # endif
14427
14428 Fence fence;
14429 Result result = static_cast<Result>( d.vkRegisterDisplayEventEXT( m_device,
14430 static_cast<VkDisplayKHR>( display ),
14431 reinterpret_cast<const VkDisplayEventInfoEXT *>( &displayEventInfo ),
14432 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
14433 reinterpret_cast<VkFence *>( &fence ) ) );
14434 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::registerDisplayEventEXTUnique" );
14435
14436 return detail::createResultValueType( result, UniqueHandle<Fence, Dispatch>( fence, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
14437 }
14438 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
14439 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14440
14441 // wrapper function for command vkGetSwapchainCounterEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainCounterEXT.html
14442 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
14443 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSwapchainCounterEXT( SwapchainKHR swapchain,
14444 SurfaceCounterFlagBitsEXT counter,
14445 uint64_t * pCounterValue,
14446 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
14447 {
14448 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
14449 return static_cast<Result>( d.vkGetSwapchainCounterEXT(
14450 static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( swapchain ), static_cast<VkSurfaceCounterFlagBitsEXT>( counter ), pCounterValue ) );
14451 }
14452
14453 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14454 // wrapper function for command vkGetSwapchainCounterEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainCounterEXT.html
14455 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
14456 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
14457 # if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS )
14458 ResultValue<uint64_t>
14459 # else
14460 typename ResultValueType<uint64_t>::type
14461 # endif
14462 Device::getSwapchainCounterEXT( SwapchainKHR swapchain, SurfaceCounterFlagBitsEXT counter, Dispatch const & d ) const
14463 {
14464 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
14465 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
14466 VULKAN_HPP_ASSERT( d.vkGetSwapchainCounterEXT && "Function <vkGetSwapchainCounterEXT> requires <VK_EXT_display_control>" );
14467 # endif
14468
14469 uint64_t counterValue;
14470 Result result = static_cast<Result>(
14471 d.vkGetSwapchainCounterEXT( m_device, static_cast<VkSwapchainKHR>( swapchain ), static_cast<VkSurfaceCounterFlagBitsEXT>( counter ), &counterValue ) );
14472
14473 # if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS )
14474 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSwapchainCounterEXT", { Result::eSuccess, Result::eErrorOutOfDateKHR } );
14475 # else
14476 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSwapchainCounterEXT" );
14477 # endif
14478
14479 # if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS )
14480 return ResultValue<uint64_t>( result, std::move( counterValue ) );
14481 # else
14482 return detail::createResultValueType( result, std::move( counterValue ) );
14483 # endif
14484 }
14485 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14486
14487 //=== VK_GOOGLE_display_timing ===
14488
14489 // wrapper function for command vkGetRefreshCycleDurationGOOGLE, see
14490 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRefreshCycleDurationGOOGLE.html
14491 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
14492 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getRefreshCycleDurationGOOGLE( SwapchainKHR swapchain,
14493 RefreshCycleDurationGOOGLE * pDisplayTimingProperties,
14494 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
14495 {
14496 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
14497 return static_cast<Result>( d.vkGetRefreshCycleDurationGOOGLE( static_cast<VkDevice>( m_device ),
14498 static_cast<VkSwapchainKHR>( swapchain ),
14499 reinterpret_cast<VkRefreshCycleDurationGOOGLE *>( pDisplayTimingProperties ) ) );
14500 }
14501
14502 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14503 // wrapper function for command vkGetRefreshCycleDurationGOOGLE, see
14504 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRefreshCycleDurationGOOGLE.html
14505 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
14506 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<RefreshCycleDurationGOOGLE>::type
14507 Device::getRefreshCycleDurationGOOGLE( SwapchainKHR swapchain, Dispatch const & d ) const
14508 {
14509 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
14510 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
14511 VULKAN_HPP_ASSERT( d.vkGetRefreshCycleDurationGOOGLE && "Function <vkGetRefreshCycleDurationGOOGLE> requires <VK_GOOGLE_display_timing>" );
14512 # endif
14513
14514 RefreshCycleDurationGOOGLE displayTimingProperties;
14515 Result result = static_cast<Result>( d.vkGetRefreshCycleDurationGOOGLE(
14516 m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<VkRefreshCycleDurationGOOGLE *>( &displayTimingProperties ) ) );
14517 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getRefreshCycleDurationGOOGLE" );
14518
14519 return detail::createResultValueType( result, std::move( displayTimingProperties ) );
14520 }
14521 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14522
14523 // wrapper function for command vkGetPastPresentationTimingGOOGLE, see
14524 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPastPresentationTimingGOOGLE.html
14525 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
14526 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getPastPresentationTimingGOOGLE( SwapchainKHR swapchain,
14527 uint32_t * pPresentationTimingCount,
14528 PastPresentationTimingGOOGLE * pPresentationTimings,
14529 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
14530 {
14531 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
14532 return static_cast<Result>( d.vkGetPastPresentationTimingGOOGLE( static_cast<VkDevice>( m_device ),
14533 static_cast<VkSwapchainKHR>( swapchain ),
14534 pPresentationTimingCount,
14535 reinterpret_cast<VkPastPresentationTimingGOOGLE *>( pPresentationTimings ) ) );
14536 }
14537
14538 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14539 // wrapper function for command vkGetPastPresentationTimingGOOGLE, see
14540 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPastPresentationTimingGOOGLE.html
14541 template <typename PastPresentationTimingGOOGLEAllocator,
14542 typename Dispatch,
14543 typename std::enable_if<std::is_same<typename PastPresentationTimingGOOGLEAllocator::value_type, PastPresentationTimingGOOGLE>::value, int>::type,
14544 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
14545 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
14546 # if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS )
14547 ResultValue<std::vector<PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator>>
14548 # else
14549 typename ResultValueType<std::vector<PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator>>::type
14550 # endif
14551 Device::getPastPresentationTimingGOOGLE( SwapchainKHR swapchain, Dispatch const & d ) const
14552 {
14553 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
14554 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
14555 VULKAN_HPP_ASSERT( d.vkGetPastPresentationTimingGOOGLE && "Function <vkGetPastPresentationTimingGOOGLE> requires <VK_GOOGLE_display_timing>" );
14556 # endif
14557
14558 std::vector<PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator> presentationTimings;
14559 uint32_t presentationTimingCount;
14560 Result result;
14561 do
14562 {
14563 result =
14564 static_cast<Result>( d.vkGetPastPresentationTimingGOOGLE( m_device, static_cast<VkSwapchainKHR>( swapchain ), &presentationTimingCount, nullptr ) );
14565 if ( ( result == Result::eSuccess ) && presentationTimingCount )
14566 {
14567 presentationTimings.resize( presentationTimingCount );
14568 result = static_cast<Result>( d.vkGetPastPresentationTimingGOOGLE( m_device,
14569 static_cast<VkSwapchainKHR>( swapchain ),
14570 &presentationTimingCount,
14571 reinterpret_cast<VkPastPresentationTimingGOOGLE *>( presentationTimings.data() ) ) );
14572 }
14573 } while ( result == Result::eIncomplete );
14574
14575 # if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS )
14576 detail::resultCheck(
14577 result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPastPresentationTimingGOOGLE", { Result::eSuccess, Result::eIncomplete, Result::eErrorOutOfDateKHR } );
14578 # else
14579 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPastPresentationTimingGOOGLE" );
14580 # endif
14581
14582 VULKAN_HPP_ASSERT( presentationTimingCount <= presentationTimings.size() );
14583 if ( presentationTimingCount < presentationTimings.size() )
14584 {
14585 presentationTimings.resize( presentationTimingCount );
14586 }
14587
14588 # if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS )
14589 return ResultValue<std::vector<PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator>>( result, std::move( presentationTimings ) );
14590 # else
14591 return detail::createResultValueType( result, std::move( presentationTimings ) );
14592 # endif
14593 }
14594
14595 // wrapper function for command vkGetPastPresentationTimingGOOGLE, see
14596 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPastPresentationTimingGOOGLE.html
14597 template <typename PastPresentationTimingGOOGLEAllocator,
14598 typename Dispatch,
14599 typename std::enable_if<std::is_same<typename PastPresentationTimingGOOGLEAllocator::value_type, PastPresentationTimingGOOGLE>::value, int>::type,
14600 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
14601 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
14602 # if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS )
14603 ResultValue<std::vector<PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator>>
14604 # else
14605 typename ResultValueType<std::vector<PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator>>::type
14606 # endif
14607 Device::getPastPresentationTimingGOOGLE( SwapchainKHR swapchain,
14608 PastPresentationTimingGOOGLEAllocator & pastPresentationTimingGOOGLEAllocator,
14609 Dispatch const & d ) const
14610 {
14611 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
14612 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
14613 VULKAN_HPP_ASSERT( d.vkGetPastPresentationTimingGOOGLE && "Function <vkGetPastPresentationTimingGOOGLE> requires <VK_GOOGLE_display_timing>" );
14614 # endif
14615
14616 std::vector<PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator> presentationTimings( pastPresentationTimingGOOGLEAllocator );
14617 uint32_t presentationTimingCount;
14618 Result result;
14619 do
14620 {
14621 result =
14622 static_cast<Result>( d.vkGetPastPresentationTimingGOOGLE( m_device, static_cast<VkSwapchainKHR>( swapchain ), &presentationTimingCount, nullptr ) );
14623 if ( ( result == Result::eSuccess ) && presentationTimingCount )
14624 {
14625 presentationTimings.resize( presentationTimingCount );
14626 result = static_cast<Result>( d.vkGetPastPresentationTimingGOOGLE( m_device,
14627 static_cast<VkSwapchainKHR>( swapchain ),
14628 &presentationTimingCount,
14629 reinterpret_cast<VkPastPresentationTimingGOOGLE *>( presentationTimings.data() ) ) );
14630 }
14631 } while ( result == Result::eIncomplete );
14632
14633 # if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS )
14634 detail::resultCheck(
14635 result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPastPresentationTimingGOOGLE", { Result::eSuccess, Result::eIncomplete, Result::eErrorOutOfDateKHR } );
14636 # else
14637 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPastPresentationTimingGOOGLE" );
14638 # endif
14639
14640 VULKAN_HPP_ASSERT( presentationTimingCount <= presentationTimings.size() );
14641 if ( presentationTimingCount < presentationTimings.size() )
14642 {
14643 presentationTimings.resize( presentationTimingCount );
14644 }
14645
14646 # if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS )
14647 return ResultValue<std::vector<PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator>>( result, std::move( presentationTimings ) );
14648 # else
14649 return detail::createResultValueType( result, std::move( presentationTimings ) );
14650 # endif
14651 }
14652 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14653
14654 //=== VK_EXT_discard_rectangles ===
14655
14656 // wrapper function for command vkCmdSetDiscardRectangleEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDiscardRectangleEXT.html
14657 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
14658 VULKAN_HPP_INLINE void CommandBuffer::setDiscardRectangleEXT( uint32_t firstDiscardRectangle,
14659 uint32_t discardRectangleCount,
14660 const Rect2D * pDiscardRectangles,
14661 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
14662 {
14663 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
14664 d.vkCmdSetDiscardRectangleEXT(
14665 static_cast<VkCommandBuffer>( m_commandBuffer ), firstDiscardRectangle, discardRectangleCount, reinterpret_cast<const VkRect2D *>( pDiscardRectangles ) );
14666 }
14667
14668 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14669 // wrapper function for command vkCmdSetDiscardRectangleEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDiscardRectangleEXT.html
14670 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
14671 VULKAN_HPP_INLINE void CommandBuffer::setDiscardRectangleEXT( uint32_t firstDiscardRectangle,
14672 ArrayProxy<const Rect2D> const & discardRectangles,
14673 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
14674 {
14675 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
14676 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
14677 VULKAN_HPP_ASSERT( d.vkCmdSetDiscardRectangleEXT && "Function <vkCmdSetDiscardRectangleEXT> requires <VK_EXT_discard_rectangles>" );
14678 # endif
14679
14680 d.vkCmdSetDiscardRectangleEXT(
14681 m_commandBuffer, firstDiscardRectangle, discardRectangles.size(), reinterpret_cast<const VkRect2D *>( discardRectangles.data() ) );
14682 }
14683 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14684
14685 // wrapper function for command vkCmdSetDiscardRectangleEnableEXT, see
14686 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDiscardRectangleEnableEXT.html
14687 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
14688 VULKAN_HPP_INLINE void CommandBuffer::setDiscardRectangleEnableEXT( Bool32 discardRectangleEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
14689 {
14690 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
14691 d.vkCmdSetDiscardRectangleEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( discardRectangleEnable ) );
14692 }
14693
14694 // wrapper function for command vkCmdSetDiscardRectangleModeEXT, see
14695 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDiscardRectangleModeEXT.html
14696 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
14697 VULKAN_HPP_INLINE void CommandBuffer::setDiscardRectangleModeEXT( DiscardRectangleModeEXT discardRectangleMode, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
14698 {
14699 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
14700 d.vkCmdSetDiscardRectangleModeEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkDiscardRectangleModeEXT>( discardRectangleMode ) );
14701 }
14702
14703 //=== VK_EXT_hdr_metadata ===
14704
14705 // wrapper function for command vkSetHdrMetadataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetHdrMetadataEXT.html
14706 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
14707 VULKAN_HPP_INLINE void Device::setHdrMetadataEXT( uint32_t swapchainCount,
14708 const SwapchainKHR * pSwapchains,
14709 const HdrMetadataEXT * pMetadata,
14710 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
14711 {
14712 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
14713 d.vkSetHdrMetadataEXT( static_cast<VkDevice>( m_device ),
14714 swapchainCount,
14715 reinterpret_cast<const VkSwapchainKHR *>( pSwapchains ),
14716 reinterpret_cast<const VkHdrMetadataEXT *>( pMetadata ) );
14717 }
14718
14719 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14720 // wrapper function for command vkSetHdrMetadataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetHdrMetadataEXT.html
14721 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
14722 VULKAN_HPP_INLINE void Device::setHdrMetadataEXT( ArrayProxy<const SwapchainKHR> const & swapchains,
14723 ArrayProxy<const HdrMetadataEXT> const & metadata,
14724 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
14725 {
14726 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
14727 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
14728 VULKAN_HPP_ASSERT( d.vkSetHdrMetadataEXT && "Function <vkSetHdrMetadataEXT> requires <VK_EXT_hdr_metadata>" );
14729 # endif
14730 # ifdef VULKAN_HPP_NO_EXCEPTIONS
14731 VULKAN_HPP_ASSERT( swapchains.size() == metadata.size() );
14732 # else
14733 if ( swapchains.size() != metadata.size() )
14734 {
14735 throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::Device::setHdrMetadataEXT: swapchains.size() != metadata.size()" );
14736 }
14737 # endif /*VULKAN_HPP_NO_EXCEPTIONS*/
14738
14739 d.vkSetHdrMetadataEXT( m_device,
14740 swapchains.size(),
14741 reinterpret_cast<const VkSwapchainKHR *>( swapchains.data() ),
14742 reinterpret_cast<const VkHdrMetadataEXT *>( metadata.data() ) );
14743 }
14744 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14745
14746 //=== VK_KHR_create_renderpass2 ===
14747
14748 // wrapper function for command vkCreateRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass2KHR.html
14749 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
14750 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createRenderPass2KHR( const RenderPassCreateInfo2 * pCreateInfo,
14751 const AllocationCallbacks * pAllocator,
14752 RenderPass * pRenderPass,
14753 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
14754 {
14755 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
14756 return static_cast<Result>( d.vkCreateRenderPass2KHR( static_cast<VkDevice>( m_device ),
14757 reinterpret_cast<const VkRenderPassCreateInfo2 *>( pCreateInfo ),
14758 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
14759 reinterpret_cast<VkRenderPass *>( pRenderPass ) ) );
14760 }
14761
14762 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14763 // wrapper function for command vkCreateRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass2KHR.html
14764 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
14765 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<RenderPass>::type
14766 Device::createRenderPass2KHR( const RenderPassCreateInfo2 & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
14767 {
14768 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
14769 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
14770 VULKAN_HPP_ASSERT( d.vkCreateRenderPass2KHR && "Function <vkCreateRenderPass2KHR> requires <VK_KHR_create_renderpass2> or <VK_VERSION_1_2>" );
14771 # endif
14772
14773 RenderPass renderPass;
14774 Result result = static_cast<Result>( d.vkCreateRenderPass2KHR( m_device,
14775 reinterpret_cast<const VkRenderPassCreateInfo2 *>( &createInfo ),
14776 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
14777 reinterpret_cast<VkRenderPass *>( &renderPass ) ) );
14778 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPass2KHR" );
14779
14780 return detail::createResultValueType( result, std::move( renderPass ) );
14781 }
14782
14783 # ifndef VULKAN_HPP_NO_SMART_HANDLE
14784 // wrapper function for command vkCreateRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass2KHR.html
14785 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
14786 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<RenderPass, Dispatch>>::type
14787 Device::createRenderPass2KHRUnique( const RenderPassCreateInfo2 & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
14788 {
14789 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
14790 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
14791 VULKAN_HPP_ASSERT( d.vkCreateRenderPass2KHR && "Function <vkCreateRenderPass2KHR> requires <VK_KHR_create_renderpass2> or <VK_VERSION_1_2>" );
14792 # endif
14793
14794 RenderPass renderPass;
14795 Result result = static_cast<Result>( d.vkCreateRenderPass2KHR( m_device,
14796 reinterpret_cast<const VkRenderPassCreateInfo2 *>( &createInfo ),
14797 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
14798 reinterpret_cast<VkRenderPass *>( &renderPass ) ) );
14799 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPass2KHRUnique" );
14800
14801 return detail::createResultValueType( result,
14802 UniqueHandle<RenderPass, Dispatch>( renderPass, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
14803 }
14804 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
14805 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14806
14807 // wrapper function for command vkCmdBeginRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderPass2KHR.html
14808 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
14809 VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass2KHR( const RenderPassBeginInfo * pRenderPassBegin,
14810 const SubpassBeginInfo * pSubpassBeginInfo,
14811 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
14812 {
14813 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
14814 d.vkCmdBeginRenderPass2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
14815 reinterpret_cast<const VkRenderPassBeginInfo *>( pRenderPassBegin ),
14816 reinterpret_cast<const VkSubpassBeginInfo *>( pSubpassBeginInfo ) );
14817 }
14818
14819 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14820 // wrapper function for command vkCmdBeginRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderPass2KHR.html
14821 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
14822 VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass2KHR( const RenderPassBeginInfo & renderPassBegin,
14823 const SubpassBeginInfo & subpassBeginInfo,
14824 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
14825 {
14826 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
14827 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
14828 VULKAN_HPP_ASSERT( d.vkCmdBeginRenderPass2KHR && "Function <vkCmdBeginRenderPass2KHR> requires <VK_KHR_create_renderpass2> or <VK_VERSION_1_2>" );
14829 # endif
14830
14831 d.vkCmdBeginRenderPass2KHR(
14832 m_commandBuffer, reinterpret_cast<const VkRenderPassBeginInfo *>( &renderPassBegin ), reinterpret_cast<const VkSubpassBeginInfo *>( &subpassBeginInfo ) );
14833 }
14834 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14835
14836 // wrapper function for command vkCmdNextSubpass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdNextSubpass2KHR.html
14837 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
14838 VULKAN_HPP_INLINE void CommandBuffer::nextSubpass2KHR( const SubpassBeginInfo * pSubpassBeginInfo,
14839 const SubpassEndInfo * pSubpassEndInfo,
14840 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
14841 {
14842 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
14843 d.vkCmdNextSubpass2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
14844 reinterpret_cast<const VkSubpassBeginInfo *>( pSubpassBeginInfo ),
14845 reinterpret_cast<const VkSubpassEndInfo *>( pSubpassEndInfo ) );
14846 }
14847
14848 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14849 // wrapper function for command vkCmdNextSubpass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdNextSubpass2KHR.html
14850 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
14851 VULKAN_HPP_INLINE void CommandBuffer::nextSubpass2KHR( const SubpassBeginInfo & subpassBeginInfo,
14852 const SubpassEndInfo & subpassEndInfo,
14853 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
14854 {
14855 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
14856 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
14857 VULKAN_HPP_ASSERT( d.vkCmdNextSubpass2KHR && "Function <vkCmdNextSubpass2KHR> requires <VK_KHR_create_renderpass2> or <VK_VERSION_1_2>" );
14858 # endif
14859
14860 d.vkCmdNextSubpass2KHR(
14861 m_commandBuffer, reinterpret_cast<const VkSubpassBeginInfo *>( &subpassBeginInfo ), reinterpret_cast<const VkSubpassEndInfo *>( &subpassEndInfo ) );
14862 }
14863 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14864
14865 // wrapper function for command vkCmdEndRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderPass2KHR.html
14866 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
14867 VULKAN_HPP_INLINE void CommandBuffer::endRenderPass2KHR( const SubpassEndInfo * pSubpassEndInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
14868 {
14869 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
14870 d.vkCmdEndRenderPass2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkSubpassEndInfo *>( pSubpassEndInfo ) );
14871 }
14872
14873 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14874 // wrapper function for command vkCmdEndRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderPass2KHR.html
14875 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
14876 VULKAN_HPP_INLINE void CommandBuffer::endRenderPass2KHR( const SubpassEndInfo & subpassEndInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
14877 {
14878 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
14879 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
14880 VULKAN_HPP_ASSERT( d.vkCmdEndRenderPass2KHR && "Function <vkCmdEndRenderPass2KHR> requires <VK_KHR_create_renderpass2> or <VK_VERSION_1_2>" );
14881 # endif
14882
14883 d.vkCmdEndRenderPass2KHR( m_commandBuffer, reinterpret_cast<const VkSubpassEndInfo *>( &subpassEndInfo ) );
14884 }
14885 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14886
14887 //=== VK_KHR_shared_presentable_image ===
14888
14889 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
14890 // wrapper function for command vkGetSwapchainStatusKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainStatusKHR.html
14891 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
14892 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSwapchainStatusKHR( SwapchainKHR swapchain, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
14893 {
14894 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
14895 return static_cast<Result>( d.vkGetSwapchainStatusKHR( static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( swapchain ) ) );
14896 }
14897 #else
14898 // wrapper function for command vkGetSwapchainStatusKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainStatusKHR.html
14899 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
14900 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSwapchainStatusKHR( SwapchainKHR swapchain, Dispatch const & d ) const
14901 {
14902 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
14903 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
14904 VULKAN_HPP_ASSERT( d.vkGetSwapchainStatusKHR && "Function <vkGetSwapchainStatusKHR> requires <VK_KHR_shared_presentable_image>" );
14905 # endif
14906
14907 Result result = static_cast<Result>( d.vkGetSwapchainStatusKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ) ) );
14908
14909 # if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS )
14910 detail::resultCheck(
14911 result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSwapchainStatusKHR", { Result::eSuccess, Result::eSuboptimalKHR, Result::eErrorOutOfDateKHR } );
14912 # else
14913 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSwapchainStatusKHR", { Result::eSuccess, Result::eSuboptimalKHR } );
14914 # endif
14915
14916 return static_cast<Result>( result );
14917 }
14918 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
14919
14920 //=== VK_KHR_external_fence_capabilities ===
14921
14922 // wrapper function for command vkGetPhysicalDeviceExternalFencePropertiesKHR, see
14923 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalFencePropertiesKHR.html
14924 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
14925 VULKAN_HPP_INLINE void PhysicalDevice::getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfo * pExternalFenceInfo,
14926 ExternalFenceProperties * pExternalFenceProperties,
14927 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
14928 {
14929 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
14930 d.vkGetPhysicalDeviceExternalFencePropertiesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
14931 reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo *>( pExternalFenceInfo ),
14932 reinterpret_cast<VkExternalFenceProperties *>( pExternalFenceProperties ) );
14933 }
14934
14935 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14936 // wrapper function for command vkGetPhysicalDeviceExternalFencePropertiesKHR, see
14937 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalFencePropertiesKHR.html
14938 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
14939 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ExternalFenceProperties
14940 PhysicalDevice::getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfo & externalFenceInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
14941 {
14942 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
14943 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
14944 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceExternalFencePropertiesKHR &&
14945 "Function <vkGetPhysicalDeviceExternalFencePropertiesKHR> requires <VK_KHR_external_fence_capabilities> or <VK_VERSION_1_1>" );
14946 # endif
14947
14948 ExternalFenceProperties externalFenceProperties;
14949 d.vkGetPhysicalDeviceExternalFencePropertiesKHR( m_physicalDevice,
14950 reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo *>( &externalFenceInfo ),
14951 reinterpret_cast<VkExternalFenceProperties *>( &externalFenceProperties ) );
14952
14953 return externalFenceProperties;
14954 }
14955 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14956
14957 #if defined( VK_USE_PLATFORM_WIN32_KHR )
14958 //=== VK_KHR_external_fence_win32 ===
14959
14960 // wrapper function for command vkImportFenceWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportFenceWin32HandleKHR.html
14961 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
14962 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR * pImportFenceWin32HandleInfo,
14963 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
14964 {
14965 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
14966 return static_cast<Result>( d.vkImportFenceWin32HandleKHR( static_cast<VkDevice>( m_device ),
14967 reinterpret_cast<const VkImportFenceWin32HandleInfoKHR *>( pImportFenceWin32HandleInfo ) ) );
14968 }
14969
14970 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14971 // wrapper function for command vkImportFenceWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportFenceWin32HandleKHR.html
14972 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
14973 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
14974 Device::importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo, Dispatch const & d ) const
14975 {
14976 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
14977 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
14978 VULKAN_HPP_ASSERT( d.vkImportFenceWin32HandleKHR && "Function <vkImportFenceWin32HandleKHR> requires <VK_KHR_external_fence_win32>" );
14979 # endif
14980
14981 Result result = static_cast<Result>(
14982 d.vkImportFenceWin32HandleKHR( m_device, reinterpret_cast<const VkImportFenceWin32HandleInfoKHR *>( &importFenceWin32HandleInfo ) ) );
14983 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::importFenceWin32HandleKHR" );
14984
14985 return detail::createResultValueType( result );
14986 }
14987 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14988
14989 // wrapper function for command vkGetFenceWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFenceWin32HandleKHR.html
14990 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
14991 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR * pGetWin32HandleInfo,
14992 HANDLE * pHandle,
14993 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
14994 {
14995 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
14996 return static_cast<Result>(
14997 d.vkGetFenceWin32HandleKHR( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkFenceGetWin32HandleInfoKHR *>( pGetWin32HandleInfo ), pHandle ) );
14998 }
14999
15000 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15001 // wrapper function for command vkGetFenceWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFenceWin32HandleKHR.html
15002 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
15003 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<HANDLE>::type
15004 Device::getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const & d ) const
15005 {
15006 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
15007 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
15008 VULKAN_HPP_ASSERT( d.vkGetFenceWin32HandleKHR && "Function <vkGetFenceWin32HandleKHR> requires <VK_KHR_external_fence_win32>" );
15009 # endif
15010
15011 HANDLE handle;
15012 Result result =
15013 static_cast<Result>( d.vkGetFenceWin32HandleKHR( m_device, reinterpret_cast<const VkFenceGetWin32HandleInfoKHR *>( &getWin32HandleInfo ), &handle ) );
15014 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getFenceWin32HandleKHR" );
15015
15016 return detail::createResultValueType( result, std::move( handle ) );
15017 }
15018 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15019 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
15020
15021 //=== VK_KHR_external_fence_fd ===
15022
15023 // wrapper function for command vkImportFenceFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportFenceFdKHR.html
15024 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
15025 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::importFenceFdKHR( const ImportFenceFdInfoKHR * pImportFenceFdInfo,
15026 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
15027 {
15028 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
15029 return static_cast<Result>(
15030 d.vkImportFenceFdKHR( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkImportFenceFdInfoKHR *>( pImportFenceFdInfo ) ) );
15031 }
15032
15033 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15034 // wrapper function for command vkImportFenceFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportFenceFdKHR.html
15035 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
15036 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
15037 Device::importFenceFdKHR( const ImportFenceFdInfoKHR & importFenceFdInfo, Dispatch const & d ) const
15038 {
15039 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
15040 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
15041 VULKAN_HPP_ASSERT( d.vkImportFenceFdKHR && "Function <vkImportFenceFdKHR> requires <VK_KHR_external_fence_fd>" );
15042 # endif
15043
15044 Result result = static_cast<Result>( d.vkImportFenceFdKHR( m_device, reinterpret_cast<const VkImportFenceFdInfoKHR *>( &importFenceFdInfo ) ) );
15045 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::importFenceFdKHR" );
15046
15047 return detail::createResultValueType( result );
15048 }
15049 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15050
15051 // wrapper function for command vkGetFenceFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFenceFdKHR.html
15052 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
15053 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getFenceFdKHR( const FenceGetFdInfoKHR * pGetFdInfo,
15054 int * pFd,
15055 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
15056 {
15057 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
15058 return static_cast<Result>( d.vkGetFenceFdKHR( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkFenceGetFdInfoKHR *>( pGetFdInfo ), pFd ) );
15059 }
15060
15061 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15062 // wrapper function for command vkGetFenceFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFenceFdKHR.html
15063 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
15064 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<int>::type Device::getFenceFdKHR( const FenceGetFdInfoKHR & getFdInfo,
15065 Dispatch const & d ) const
15066 {
15067 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
15068 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
15069 VULKAN_HPP_ASSERT( d.vkGetFenceFdKHR && "Function <vkGetFenceFdKHR> requires <VK_KHR_external_fence_fd>" );
15070 # endif
15071
15072 int fd;
15073 Result result = static_cast<Result>( d.vkGetFenceFdKHR( m_device, reinterpret_cast<const VkFenceGetFdInfoKHR *>( &getFdInfo ), &fd ) );
15074 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getFenceFdKHR" );
15075
15076 return detail::createResultValueType( result, std::move( fd ) );
15077 }
15078 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15079
15080 //=== VK_KHR_performance_query ===
15081
15082 // wrapper function for command vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR, see
15083 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR.html
15084 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
15085 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
15086 PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex,
15087 uint32_t * pCounterCount,
15088 PerformanceCounterKHR * pCounters,
15089 PerformanceCounterDescriptionKHR * pCounterDescriptions,
15090 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
15091 {
15092 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
15093 return static_cast<Result>(
15094 d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
15095 queueFamilyIndex,
15096 pCounterCount,
15097 reinterpret_cast<VkPerformanceCounterKHR *>( pCounters ),
15098 reinterpret_cast<VkPerformanceCounterDescriptionKHR *>( pCounterDescriptions ) ) );
15099 }
15100
15101 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15102 // wrapper function for command vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR, see
15103 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR.html
15104 template <typename PerformanceCounterKHRAllocator,
15105 typename PerformanceCounterDescriptionKHRAllocator,
15106 typename Dispatch,
15107 typename std::enable_if<std::is_same<typename PerformanceCounterKHRAllocator::value_type, PerformanceCounterKHR>::value &&
15108 std::is_same<typename PerformanceCounterDescriptionKHRAllocator::value_type, PerformanceCounterDescriptionKHR>::value,
15109 int>::type,
15110 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
15111 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
15112 typename ResultValueType<std::pair<std::vector<PerformanceCounterKHR, PerformanceCounterKHRAllocator>,
15113 std::vector<PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator>>>::type
15114 PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex, Dispatch const & d ) const
15115 {
15116 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
15117 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
15118 VULKAN_HPP_ASSERT( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR &&
15119 "Function <vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR> requires <VK_KHR_performance_query>" );
15120 # endif
15121
15122 std::pair<std::vector<PerformanceCounterKHR, PerformanceCounterKHRAllocator>,
15123 std::vector<PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator>>
15124 data_;
15125 std::vector<PerformanceCounterKHR, PerformanceCounterKHRAllocator> & counters = data_.first;
15126 std::vector<PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator> & counterDescriptions = data_.second;
15127 uint32_t counterCount;
15128 Result result;
15129 do
15130 {
15131 result = static_cast<Result>(
15132 d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( m_physicalDevice, queueFamilyIndex, &counterCount, nullptr, nullptr ) );
15133 if ( ( result == Result::eSuccess ) && counterCount )
15134 {
15135 counters.resize( counterCount );
15136 counterDescriptions.resize( counterCount );
15137 result = static_cast<Result>( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
15138 m_physicalDevice,
15139 queueFamilyIndex,
15140 &counterCount,
15141 reinterpret_cast<VkPerformanceCounterKHR *>( counters.data() ),
15142 reinterpret_cast<VkPerformanceCounterDescriptionKHR *>( counterDescriptions.data() ) ) );
15143 }
15144 } while ( result == Result::eIncomplete );
15145 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR" );
15146 VULKAN_HPP_ASSERT( counterCount <= counters.size() );
15147 if ( counterCount < counters.size() )
15148 {
15149 counters.resize( counterCount );
15150 counterDescriptions.resize( counterCount );
15151 }
15152 return detail::createResultValueType( result, std::move( data_ ) );
15153 }
15154
15155 // wrapper function for command vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR, see
15156 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR.html
15157 template <typename PerformanceCounterKHRAllocator,
15158 typename PerformanceCounterDescriptionKHRAllocator,
15159 typename Dispatch,
15160 typename std::enable_if<std::is_same<typename PerformanceCounterKHRAllocator::value_type, PerformanceCounterKHR>::value &&
15161 std::is_same<typename PerformanceCounterDescriptionKHRAllocator::value_type, PerformanceCounterDescriptionKHR>::value,
15162 int>::type,
15163 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
15164 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
15165 typename ResultValueType<std::pair<std::vector<PerformanceCounterKHR, PerformanceCounterKHRAllocator>,
15166 std::vector<PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator>>>::type
15167 PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex,
15168 PerformanceCounterKHRAllocator & performanceCounterKHRAllocator,
15169 PerformanceCounterDescriptionKHRAllocator & performanceCounterDescriptionKHRAllocator,
15170 Dispatch const & d ) const
15171 {
15172 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
15173 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
15174 VULKAN_HPP_ASSERT( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR &&
15175 "Function <vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR> requires <VK_KHR_performance_query>" );
15176 # endif
15177
15178 std::pair<std::vector<PerformanceCounterKHR, PerformanceCounterKHRAllocator>,
15179 std::vector<PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator>>
15180 data_(
15181 std::piecewise_construct, std::forward_as_tuple( performanceCounterKHRAllocator ), std::forward_as_tuple( performanceCounterDescriptionKHRAllocator ) );
15182 std::vector<PerformanceCounterKHR, PerformanceCounterKHRAllocator> & counters = data_.first;
15183 std::vector<PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator> & counterDescriptions = data_.second;
15184 uint32_t counterCount;
15185 Result result;
15186 do
15187 {
15188 result = static_cast<Result>(
15189 d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( m_physicalDevice, queueFamilyIndex, &counterCount, nullptr, nullptr ) );
15190 if ( ( result == Result::eSuccess ) && counterCount )
15191 {
15192 counters.resize( counterCount );
15193 counterDescriptions.resize( counterCount );
15194 result = static_cast<Result>( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
15195 m_physicalDevice,
15196 queueFamilyIndex,
15197 &counterCount,
15198 reinterpret_cast<VkPerformanceCounterKHR *>( counters.data() ),
15199 reinterpret_cast<VkPerformanceCounterDescriptionKHR *>( counterDescriptions.data() ) ) );
15200 }
15201 } while ( result == Result::eIncomplete );
15202 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR" );
15203 VULKAN_HPP_ASSERT( counterCount <= counters.size() );
15204 if ( counterCount < counters.size() )
15205 {
15206 counters.resize( counterCount );
15207 counterDescriptions.resize( counterCount );
15208 }
15209 return detail::createResultValueType( result, std::move( data_ ) );
15210 }
15211 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15212
15213 // wrapper function for command vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR, see
15214 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR.html
15215 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
15216 VULKAN_HPP_INLINE void PhysicalDevice::getQueueFamilyPerformanceQueryPassesKHR( const QueryPoolPerformanceCreateInfoKHR * pPerformanceQueryCreateInfo,
15217 uint32_t * pNumPasses,
15218 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
15219 {
15220 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
15221 d.vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
15222 reinterpret_cast<const VkQueryPoolPerformanceCreateInfoKHR *>( pPerformanceQueryCreateInfo ),
15223 pNumPasses );
15224 }
15225
15226 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15227 // wrapper function for command vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR, see
15228 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR.html
15229 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
15230 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint32_t PhysicalDevice::getQueueFamilyPerformanceQueryPassesKHR(
15231 const QueryPoolPerformanceCreateInfoKHR & performanceQueryCreateInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
15232 {
15233 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
15234 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
15235 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR &&
15236 "Function <vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR> requires <VK_KHR_performance_query>" );
15237 # endif
15238
15239 uint32_t numPasses;
15240 d.vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(
15241 m_physicalDevice, reinterpret_cast<const VkQueryPoolPerformanceCreateInfoKHR *>( &performanceQueryCreateInfo ), &numPasses );
15242
15243 return numPasses;
15244 }
15245 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15246
15247 // wrapper function for command vkAcquireProfilingLockKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireProfilingLockKHR.html
15248 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
15249 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::acquireProfilingLockKHR( const AcquireProfilingLockInfoKHR * pInfo,
15250 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
15251 {
15252 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
15253 return static_cast<Result>(
15254 d.vkAcquireProfilingLockKHR( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkAcquireProfilingLockInfoKHR *>( pInfo ) ) );
15255 }
15256
15257 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15258 // wrapper function for command vkAcquireProfilingLockKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireProfilingLockKHR.html
15259 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
15260 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
15261 Device::acquireProfilingLockKHR( const AcquireProfilingLockInfoKHR & info, Dispatch const & d ) const
15262 {
15263 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
15264 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
15265 VULKAN_HPP_ASSERT( d.vkAcquireProfilingLockKHR && "Function <vkAcquireProfilingLockKHR> requires <VK_KHR_performance_query>" );
15266 # endif
15267
15268 Result result = static_cast<Result>( d.vkAcquireProfilingLockKHR( m_device, reinterpret_cast<const VkAcquireProfilingLockInfoKHR *>( &info ) ) );
15269 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::acquireProfilingLockKHR" );
15270
15271 return detail::createResultValueType( result );
15272 }
15273 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15274
15275 // wrapper function for command vkReleaseProfilingLockKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseProfilingLockKHR.html
15276 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
15277 VULKAN_HPP_INLINE void Device::releaseProfilingLockKHR( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
15278 {
15279 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
15280 d.vkReleaseProfilingLockKHR( static_cast<VkDevice>( m_device ) );
15281 }
15282
15283 //=== VK_KHR_get_surface_capabilities2 ===
15284
15285 // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilities2KHR, see
15286 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilities2KHR.html
15287 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
15288 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
15289 SurfaceCapabilities2KHR * pSurfaceCapabilities,
15290 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
15291 {
15292 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
15293 return static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilities2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
15294 reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( pSurfaceInfo ),
15295 reinterpret_cast<VkSurfaceCapabilities2KHR *>( pSurfaceCapabilities ) ) );
15296 }
15297
15298 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15299 // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilities2KHR, see
15300 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilities2KHR.html
15301 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
15302 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<SurfaceCapabilities2KHR>::type
15303 PhysicalDevice::getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d ) const
15304 {
15305 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
15306 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
15307 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfaceCapabilities2KHR &&
15308 "Function <vkGetPhysicalDeviceSurfaceCapabilities2KHR> requires <VK_KHR_get_surface_capabilities2>" );
15309 # endif
15310
15311 SurfaceCapabilities2KHR surfaceCapabilities;
15312 Result result =
15313 static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilities2KHR( m_physicalDevice,
15314 reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ),
15315 reinterpret_cast<VkSurfaceCapabilities2KHR *>( &surfaceCapabilities ) ) );
15316 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilities2KHR" );
15317
15318 return detail::createResultValueType( result, std::move( surfaceCapabilities ) );
15319 }
15320
15321 // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilities2KHR, see
15322 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilities2KHR.html
15323 template <typename X, typename Y, typename... Z, typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
15324 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<StructureChain<X, Y, Z...>>::type
15325 PhysicalDevice::getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d ) const
15326 {
15327 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
15328 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
15329 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfaceCapabilities2KHR &&
15330 "Function <vkGetPhysicalDeviceSurfaceCapabilities2KHR> requires <VK_KHR_get_surface_capabilities2>" );
15331 # endif
15332
15333 StructureChain<X, Y, Z...> structureChain;
15334 SurfaceCapabilities2KHR & surfaceCapabilities = structureChain.template get<SurfaceCapabilities2KHR>();
15335 Result result =
15336 static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilities2KHR( m_physicalDevice,
15337 reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ),
15338 reinterpret_cast<VkSurfaceCapabilities2KHR *>( &surfaceCapabilities ) ) );
15339 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilities2KHR" );
15340
15341 return detail::createResultValueType( result, std::move( structureChain ) );
15342 }
15343 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15344
15345 // wrapper function for command vkGetPhysicalDeviceSurfaceFormats2KHR, see
15346 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormats2KHR.html
15347 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
15348 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
15349 uint32_t * pSurfaceFormatCount,
15350 SurfaceFormat2KHR * pSurfaceFormats,
15351 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
15352 {
15353 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
15354 return static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormats2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
15355 reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( pSurfaceInfo ),
15356 pSurfaceFormatCount,
15357 reinterpret_cast<VkSurfaceFormat2KHR *>( pSurfaceFormats ) ) );
15358 }
15359
15360 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15361 // wrapper function for command vkGetPhysicalDeviceSurfaceFormats2KHR, see
15362 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormats2KHR.html
15363 template <typename SurfaceFormat2KHRAllocator,
15364 typename Dispatch,
15365 typename std::enable_if<std::is_same<typename SurfaceFormat2KHRAllocator::value_type, SurfaceFormat2KHR>::value, int>::type,
15366 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
15367 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<SurfaceFormat2KHR, SurfaceFormat2KHRAllocator>>::type
15368 PhysicalDevice::getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d ) const
15369 {
15370 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
15371 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
15372 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfaceFormats2KHR &&
15373 "Function <vkGetPhysicalDeviceSurfaceFormats2KHR> requires <VK_KHR_get_surface_capabilities2>" );
15374 # endif
15375
15376 std::vector<SurfaceFormat2KHR, SurfaceFormat2KHRAllocator> surfaceFormats;
15377 uint32_t surfaceFormatCount;
15378 Result result;
15379 do
15380 {
15381 result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormats2KHR(
15382 m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ), &surfaceFormatCount, nullptr ) );
15383 if ( ( result == Result::eSuccess ) && surfaceFormatCount )
15384 {
15385 surfaceFormats.resize( surfaceFormatCount );
15386 result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormats2KHR( m_physicalDevice,
15387 reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ),
15388 &surfaceFormatCount,
15389 reinterpret_cast<VkSurfaceFormat2KHR *>( surfaceFormats.data() ) ) );
15390 }
15391 } while ( result == Result::eIncomplete );
15392 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceFormats2KHR" );
15393 VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() );
15394 if ( surfaceFormatCount < surfaceFormats.size() )
15395 {
15396 surfaceFormats.resize( surfaceFormatCount );
15397 }
15398 return detail::createResultValueType( result, std::move( surfaceFormats ) );
15399 }
15400
15401 // wrapper function for command vkGetPhysicalDeviceSurfaceFormats2KHR, see
15402 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormats2KHR.html
15403 template <typename SurfaceFormat2KHRAllocator,
15404 typename Dispatch,
15405 typename std::enable_if<std::is_same<typename SurfaceFormat2KHRAllocator::value_type, SurfaceFormat2KHR>::value, int>::type,
15406 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
15407 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<SurfaceFormat2KHR, SurfaceFormat2KHRAllocator>>::type
15408 PhysicalDevice::getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
15409 SurfaceFormat2KHRAllocator & surfaceFormat2KHRAllocator,
15410 Dispatch const & d ) const
15411 {
15412 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
15413 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
15414 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfaceFormats2KHR &&
15415 "Function <vkGetPhysicalDeviceSurfaceFormats2KHR> requires <VK_KHR_get_surface_capabilities2>" );
15416 # endif
15417
15418 std::vector<SurfaceFormat2KHR, SurfaceFormat2KHRAllocator> surfaceFormats( surfaceFormat2KHRAllocator );
15419 uint32_t surfaceFormatCount;
15420 Result result;
15421 do
15422 {
15423 result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormats2KHR(
15424 m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ), &surfaceFormatCount, nullptr ) );
15425 if ( ( result == Result::eSuccess ) && surfaceFormatCount )
15426 {
15427 surfaceFormats.resize( surfaceFormatCount );
15428 result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormats2KHR( m_physicalDevice,
15429 reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ),
15430 &surfaceFormatCount,
15431 reinterpret_cast<VkSurfaceFormat2KHR *>( surfaceFormats.data() ) ) );
15432 }
15433 } while ( result == Result::eIncomplete );
15434 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceFormats2KHR" );
15435 VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() );
15436 if ( surfaceFormatCount < surfaceFormats.size() )
15437 {
15438 surfaceFormats.resize( surfaceFormatCount );
15439 }
15440 return detail::createResultValueType( result, std::move( surfaceFormats ) );
15441 }
15442
15443 // wrapper function for command vkGetPhysicalDeviceSurfaceFormats2KHR, see
15444 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormats2KHR.html
15445 template <typename StructureChain,
15446 typename StructureChainAllocator,
15447 typename Dispatch,
15448 typename std::enable_if<std::is_same<typename StructureChainAllocator::value_type, StructureChain>::value, int>::type,
15449 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
15450 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<StructureChain, StructureChainAllocator>>::type
15451 PhysicalDevice::getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d ) const
15452 {
15453 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
15454 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
15455 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfaceFormats2KHR &&
15456 "Function <vkGetPhysicalDeviceSurfaceFormats2KHR> requires <VK_KHR_get_surface_capabilities2>" );
15457 # endif
15458
15459 std::vector<StructureChain, StructureChainAllocator> structureChains;
15460 std::vector<SurfaceFormat2KHR> surfaceFormats;
15461 uint32_t surfaceFormatCount;
15462 Result result;
15463 do
15464 {
15465 result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormats2KHR(
15466 m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ), &surfaceFormatCount, nullptr ) );
15467 if ( ( result == Result::eSuccess ) && surfaceFormatCount )
15468 {
15469 structureChains.resize( surfaceFormatCount );
15470 surfaceFormats.resize( surfaceFormatCount );
15471 for ( uint32_t i = 0; i < surfaceFormatCount; i++ )
15472 {
15473 surfaceFormats[i].pNext = structureChains[i].template get<SurfaceFormat2KHR>().pNext;
15474 }
15475 result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormats2KHR( m_physicalDevice,
15476 reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ),
15477 &surfaceFormatCount,
15478 reinterpret_cast<VkSurfaceFormat2KHR *>( surfaceFormats.data() ) ) );
15479 }
15480 } while ( result == Result::eIncomplete );
15481 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceFormats2KHR" );
15482 VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() );
15483 if ( surfaceFormatCount < surfaceFormats.size() )
15484 {
15485 structureChains.resize( surfaceFormatCount );
15486 }
15487 for ( uint32_t i = 0; i < surfaceFormatCount; i++ )
15488 {
15489 structureChains[i].template get<SurfaceFormat2KHR>() = surfaceFormats[i];
15490 }
15491 return detail::createResultValueType( result, std::move( structureChains ) );
15492 }
15493
15494 // wrapper function for command vkGetPhysicalDeviceSurfaceFormats2KHR, see
15495 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormats2KHR.html
15496 template <typename StructureChain,
15497 typename StructureChainAllocator,
15498 typename Dispatch,
15499 typename std::enable_if<std::is_same<typename StructureChainAllocator::value_type, StructureChain>::value, int>::type,
15500 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
15501 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<StructureChain, StructureChainAllocator>>::type
15502 PhysicalDevice::getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
15503 StructureChainAllocator & structureChainAllocator,
15504 Dispatch const & d ) const
15505 {
15506 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
15507 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
15508 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfaceFormats2KHR &&
15509 "Function <vkGetPhysicalDeviceSurfaceFormats2KHR> requires <VK_KHR_get_surface_capabilities2>" );
15510 # endif
15511
15512 std::vector<StructureChain, StructureChainAllocator> structureChains( structureChainAllocator );
15513 std::vector<SurfaceFormat2KHR> surfaceFormats;
15514 uint32_t surfaceFormatCount;
15515 Result result;
15516 do
15517 {
15518 result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormats2KHR(
15519 m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ), &surfaceFormatCount, nullptr ) );
15520 if ( ( result == Result::eSuccess ) && surfaceFormatCount )
15521 {
15522 structureChains.resize( surfaceFormatCount );
15523 surfaceFormats.resize( surfaceFormatCount );
15524 for ( uint32_t i = 0; i < surfaceFormatCount; i++ )
15525 {
15526 surfaceFormats[i].pNext = structureChains[i].template get<SurfaceFormat2KHR>().pNext;
15527 }
15528 result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormats2KHR( m_physicalDevice,
15529 reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ),
15530 &surfaceFormatCount,
15531 reinterpret_cast<VkSurfaceFormat2KHR *>( surfaceFormats.data() ) ) );
15532 }
15533 } while ( result == Result::eIncomplete );
15534 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceFormats2KHR" );
15535 VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() );
15536 if ( surfaceFormatCount < surfaceFormats.size() )
15537 {
15538 structureChains.resize( surfaceFormatCount );
15539 }
15540 for ( uint32_t i = 0; i < surfaceFormatCount; i++ )
15541 {
15542 structureChains[i].template get<SurfaceFormat2KHR>() = surfaceFormats[i];
15543 }
15544 return detail::createResultValueType( result, std::move( structureChains ) );
15545 }
15546 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15547
15548 //=== VK_KHR_get_display_properties2 ===
15549
15550 // wrapper function for command vkGetPhysicalDeviceDisplayProperties2KHR, see
15551 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayProperties2KHR.html
15552 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
15553 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayProperties2KHR( uint32_t * pPropertyCount,
15554 DisplayProperties2KHR * pProperties,
15555 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
15556 {
15557 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
15558 return static_cast<Result>( d.vkGetPhysicalDeviceDisplayProperties2KHR(
15559 static_cast<VkPhysicalDevice>( m_physicalDevice ), pPropertyCount, reinterpret_cast<VkDisplayProperties2KHR *>( pProperties ) ) );
15560 }
15561
15562 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15563 // wrapper function for command vkGetPhysicalDeviceDisplayProperties2KHR, see
15564 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayProperties2KHR.html
15565 template <typename DisplayProperties2KHRAllocator,
15566 typename Dispatch,
15567 typename std::enable_if<std::is_same<typename DisplayProperties2KHRAllocator::value_type, DisplayProperties2KHR>::value, int>::type,
15568 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
15569 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayProperties2KHR, DisplayProperties2KHRAllocator>>::type
15570 PhysicalDevice::getDisplayProperties2KHR( Dispatch const & d ) const
15571 {
15572 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
15573 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
15574 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceDisplayProperties2KHR &&
15575 "Function <vkGetPhysicalDeviceDisplayProperties2KHR> requires <VK_KHR_get_display_properties2>" );
15576 # endif
15577
15578 std::vector<DisplayProperties2KHR, DisplayProperties2KHRAllocator> properties;
15579 uint32_t propertyCount;
15580 Result result;
15581 do
15582 {
15583 result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayProperties2KHR( m_physicalDevice, &propertyCount, nullptr ) );
15584 if ( ( result == Result::eSuccess ) && propertyCount )
15585 {
15586 properties.resize( propertyCount );
15587 result = static_cast<Result>(
15588 d.vkGetPhysicalDeviceDisplayProperties2KHR( m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayProperties2KHR *>( properties.data() ) ) );
15589 }
15590 } while ( result == Result::eIncomplete );
15591 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayProperties2KHR" );
15592 VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
15593 if ( propertyCount < properties.size() )
15594 {
15595 properties.resize( propertyCount );
15596 }
15597 return detail::createResultValueType( result, std::move( properties ) );
15598 }
15599
15600 // wrapper function for command vkGetPhysicalDeviceDisplayProperties2KHR, see
15601 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayProperties2KHR.html
15602 template <typename DisplayProperties2KHRAllocator,
15603 typename Dispatch,
15604 typename std::enable_if<std::is_same<typename DisplayProperties2KHRAllocator::value_type, DisplayProperties2KHR>::value, int>::type,
15605 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
15606 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayProperties2KHR, DisplayProperties2KHRAllocator>>::type
15607 PhysicalDevice::getDisplayProperties2KHR( DisplayProperties2KHRAllocator & displayProperties2KHRAllocator, Dispatch const & d ) const
15608 {
15609 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
15610 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
15611 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceDisplayProperties2KHR &&
15612 "Function <vkGetPhysicalDeviceDisplayProperties2KHR> requires <VK_KHR_get_display_properties2>" );
15613 # endif
15614
15615 std::vector<DisplayProperties2KHR, DisplayProperties2KHRAllocator> properties( displayProperties2KHRAllocator );
15616 uint32_t propertyCount;
15617 Result result;
15618 do
15619 {
15620 result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayProperties2KHR( m_physicalDevice, &propertyCount, nullptr ) );
15621 if ( ( result == Result::eSuccess ) && propertyCount )
15622 {
15623 properties.resize( propertyCount );
15624 result = static_cast<Result>(
15625 d.vkGetPhysicalDeviceDisplayProperties2KHR( m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayProperties2KHR *>( properties.data() ) ) );
15626 }
15627 } while ( result == Result::eIncomplete );
15628 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayProperties2KHR" );
15629 VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
15630 if ( propertyCount < properties.size() )
15631 {
15632 properties.resize( propertyCount );
15633 }
15634 return detail::createResultValueType( result, std::move( properties ) );
15635 }
15636 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15637
15638 // wrapper function for command vkGetPhysicalDeviceDisplayPlaneProperties2KHR, see
15639 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPlaneProperties2KHR.html
15640 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
15641 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlaneProperties2KHR( uint32_t * pPropertyCount,
15642 DisplayPlaneProperties2KHR * pProperties,
15643 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
15644 {
15645 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
15646 return static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR(
15647 static_cast<VkPhysicalDevice>( m_physicalDevice ), pPropertyCount, reinterpret_cast<VkDisplayPlaneProperties2KHR *>( pProperties ) ) );
15648 }
15649
15650 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15651 // wrapper function for command vkGetPhysicalDeviceDisplayPlaneProperties2KHR, see
15652 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPlaneProperties2KHR.html
15653 template <typename DisplayPlaneProperties2KHRAllocator,
15654 typename Dispatch,
15655 typename std::enable_if<std::is_same<typename DisplayPlaneProperties2KHRAllocator::value_type, DisplayPlaneProperties2KHR>::value, int>::type,
15656 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
15657 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayPlaneProperties2KHR, DisplayPlaneProperties2KHRAllocator>>::type
15658 PhysicalDevice::getDisplayPlaneProperties2KHR( Dispatch const & d ) const
15659 {
15660 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
15661 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
15662 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR &&
15663 "Function <vkGetPhysicalDeviceDisplayPlaneProperties2KHR> requires <VK_KHR_get_display_properties2>" );
15664 # endif
15665
15666 std::vector<DisplayPlaneProperties2KHR, DisplayPlaneProperties2KHRAllocator> properties;
15667 uint32_t propertyCount;
15668 Result result;
15669 do
15670 {
15671 result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR( m_physicalDevice, &propertyCount, nullptr ) );
15672 if ( ( result == Result::eSuccess ) && propertyCount )
15673 {
15674 properties.resize( propertyCount );
15675 result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR(
15676 m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayPlaneProperties2KHR *>( properties.data() ) ) );
15677 }
15678 } while ( result == Result::eIncomplete );
15679 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneProperties2KHR" );
15680 VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
15681 if ( propertyCount < properties.size() )
15682 {
15683 properties.resize( propertyCount );
15684 }
15685 return detail::createResultValueType( result, std::move( properties ) );
15686 }
15687
15688 // wrapper function for command vkGetPhysicalDeviceDisplayPlaneProperties2KHR, see
15689 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPlaneProperties2KHR.html
15690 template <typename DisplayPlaneProperties2KHRAllocator,
15691 typename Dispatch,
15692 typename std::enable_if<std::is_same<typename DisplayPlaneProperties2KHRAllocator::value_type, DisplayPlaneProperties2KHR>::value, int>::type,
15693 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
15694 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayPlaneProperties2KHR, DisplayPlaneProperties2KHRAllocator>>::type
15695 PhysicalDevice::getDisplayPlaneProperties2KHR( DisplayPlaneProperties2KHRAllocator & displayPlaneProperties2KHRAllocator, Dispatch const & d ) const
15696 {
15697 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
15698 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
15699 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR &&
15700 "Function <vkGetPhysicalDeviceDisplayPlaneProperties2KHR> requires <VK_KHR_get_display_properties2>" );
15701 # endif
15702
15703 std::vector<DisplayPlaneProperties2KHR, DisplayPlaneProperties2KHRAllocator> properties( displayPlaneProperties2KHRAllocator );
15704 uint32_t propertyCount;
15705 Result result;
15706 do
15707 {
15708 result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR( m_physicalDevice, &propertyCount, nullptr ) );
15709 if ( ( result == Result::eSuccess ) && propertyCount )
15710 {
15711 properties.resize( propertyCount );
15712 result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR(
15713 m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayPlaneProperties2KHR *>( properties.data() ) ) );
15714 }
15715 } while ( result == Result::eIncomplete );
15716 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneProperties2KHR" );
15717 VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
15718 if ( propertyCount < properties.size() )
15719 {
15720 properties.resize( propertyCount );
15721 }
15722 return detail::createResultValueType( result, std::move( properties ) );
15723 }
15724 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15725
15726 // wrapper function for command vkGetDisplayModeProperties2KHR, see
15727 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModeProperties2KHR.html
15728 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
15729 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayModeProperties2KHR( DisplayKHR display,
15730 uint32_t * pPropertyCount,
15731 DisplayModeProperties2KHR * pProperties,
15732 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
15733 {
15734 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
15735 return static_cast<Result>( d.vkGetDisplayModeProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
15736 static_cast<VkDisplayKHR>( display ),
15737 pPropertyCount,
15738 reinterpret_cast<VkDisplayModeProperties2KHR *>( pProperties ) ) );
15739 }
15740
15741 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15742 // wrapper function for command vkGetDisplayModeProperties2KHR, see
15743 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModeProperties2KHR.html
15744 template <typename DisplayModeProperties2KHRAllocator,
15745 typename Dispatch,
15746 typename std::enable_if<std::is_same<typename DisplayModeProperties2KHRAllocator::value_type, DisplayModeProperties2KHR>::value, int>::type,
15747 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
15748 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayModeProperties2KHR, DisplayModeProperties2KHRAllocator>>::type
15749 PhysicalDevice::getDisplayModeProperties2KHR( DisplayKHR display, Dispatch const & d ) const
15750 {
15751 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
15752 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
15753 VULKAN_HPP_ASSERT( d.vkGetDisplayModeProperties2KHR && "Function <vkGetDisplayModeProperties2KHR> requires <VK_KHR_get_display_properties2>" );
15754 # endif
15755
15756 std::vector<DisplayModeProperties2KHR, DisplayModeProperties2KHRAllocator> properties;
15757 uint32_t propertyCount;
15758 Result result;
15759 do
15760 {
15761 result = static_cast<Result>( d.vkGetDisplayModeProperties2KHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, nullptr ) );
15762 if ( ( result == Result::eSuccess ) && propertyCount )
15763 {
15764 properties.resize( propertyCount );
15765 result = static_cast<Result>( d.vkGetDisplayModeProperties2KHR(
15766 m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, reinterpret_cast<VkDisplayModeProperties2KHR *>( properties.data() ) ) );
15767 }
15768 } while ( result == Result::eIncomplete );
15769 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayModeProperties2KHR" );
15770 VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
15771 if ( propertyCount < properties.size() )
15772 {
15773 properties.resize( propertyCount );
15774 }
15775 return detail::createResultValueType( result, std::move( properties ) );
15776 }
15777
15778 // wrapper function for command vkGetDisplayModeProperties2KHR, see
15779 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModeProperties2KHR.html
15780 template <typename DisplayModeProperties2KHRAllocator,
15781 typename Dispatch,
15782 typename std::enable_if<std::is_same<typename DisplayModeProperties2KHRAllocator::value_type, DisplayModeProperties2KHR>::value, int>::type,
15783 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
15784 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayModeProperties2KHR, DisplayModeProperties2KHRAllocator>>::type
15785 PhysicalDevice::getDisplayModeProperties2KHR( DisplayKHR display,
15786 DisplayModeProperties2KHRAllocator & displayModeProperties2KHRAllocator,
15787 Dispatch const & d ) const
15788 {
15789 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
15790 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
15791 VULKAN_HPP_ASSERT( d.vkGetDisplayModeProperties2KHR && "Function <vkGetDisplayModeProperties2KHR> requires <VK_KHR_get_display_properties2>" );
15792 # endif
15793
15794 std::vector<DisplayModeProperties2KHR, DisplayModeProperties2KHRAllocator> properties( displayModeProperties2KHRAllocator );
15795 uint32_t propertyCount;
15796 Result result;
15797 do
15798 {
15799 result = static_cast<Result>( d.vkGetDisplayModeProperties2KHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, nullptr ) );
15800 if ( ( result == Result::eSuccess ) && propertyCount )
15801 {
15802 properties.resize( propertyCount );
15803 result = static_cast<Result>( d.vkGetDisplayModeProperties2KHR(
15804 m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, reinterpret_cast<VkDisplayModeProperties2KHR *>( properties.data() ) ) );
15805 }
15806 } while ( result == Result::eIncomplete );
15807 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayModeProperties2KHR" );
15808 VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
15809 if ( propertyCount < properties.size() )
15810 {
15811 properties.resize( propertyCount );
15812 }
15813 return detail::createResultValueType( result, std::move( properties ) );
15814 }
15815
15816 // wrapper function for command vkGetDisplayModeProperties2KHR, see
15817 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModeProperties2KHR.html
15818 template <typename StructureChain,
15819 typename StructureChainAllocator,
15820 typename Dispatch,
15821 typename std::enable_if<std::is_same<typename StructureChainAllocator::value_type, StructureChain>::value, int>::type,
15822 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
15823 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<StructureChain, StructureChainAllocator>>::type
15824 PhysicalDevice::getDisplayModeProperties2KHR( DisplayKHR display, Dispatch const & d ) const
15825 {
15826 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
15827 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
15828 VULKAN_HPP_ASSERT( d.vkGetDisplayModeProperties2KHR && "Function <vkGetDisplayModeProperties2KHR> requires <VK_KHR_get_display_properties2>" );
15829 # endif
15830
15831 std::vector<StructureChain, StructureChainAllocator> structureChains;
15832 std::vector<DisplayModeProperties2KHR> properties;
15833 uint32_t propertyCount;
15834 Result result;
15835 do
15836 {
15837 result = static_cast<Result>( d.vkGetDisplayModeProperties2KHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, nullptr ) );
15838 if ( ( result == Result::eSuccess ) && propertyCount )
15839 {
15840 structureChains.resize( propertyCount );
15841 properties.resize( propertyCount );
15842 for ( uint32_t i = 0; i < propertyCount; i++ )
15843 {
15844 properties[i].pNext = structureChains[i].template get<DisplayModeProperties2KHR>().pNext;
15845 }
15846 result = static_cast<Result>( d.vkGetDisplayModeProperties2KHR(
15847 m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, reinterpret_cast<VkDisplayModeProperties2KHR *>( properties.data() ) ) );
15848 }
15849 } while ( result == Result::eIncomplete );
15850 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayModeProperties2KHR" );
15851 VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
15852 if ( propertyCount < properties.size() )
15853 {
15854 structureChains.resize( propertyCount );
15855 }
15856 for ( uint32_t i = 0; i < propertyCount; i++ )
15857 {
15858 structureChains[i].template get<DisplayModeProperties2KHR>() = properties[i];
15859 }
15860 return detail::createResultValueType( result, std::move( structureChains ) );
15861 }
15862
15863 // wrapper function for command vkGetDisplayModeProperties2KHR, see
15864 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModeProperties2KHR.html
15865 template <typename StructureChain,
15866 typename StructureChainAllocator,
15867 typename Dispatch,
15868 typename std::enable_if<std::is_same<typename StructureChainAllocator::value_type, StructureChain>::value, int>::type,
15869 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
15870 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<StructureChain, StructureChainAllocator>>::type
15871 PhysicalDevice::getDisplayModeProperties2KHR( DisplayKHR display, StructureChainAllocator & structureChainAllocator, Dispatch const & d ) const
15872 {
15873 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
15874 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
15875 VULKAN_HPP_ASSERT( d.vkGetDisplayModeProperties2KHR && "Function <vkGetDisplayModeProperties2KHR> requires <VK_KHR_get_display_properties2>" );
15876 # endif
15877
15878 std::vector<StructureChain, StructureChainAllocator> structureChains( structureChainAllocator );
15879 std::vector<DisplayModeProperties2KHR> properties;
15880 uint32_t propertyCount;
15881 Result result;
15882 do
15883 {
15884 result = static_cast<Result>( d.vkGetDisplayModeProperties2KHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, nullptr ) );
15885 if ( ( result == Result::eSuccess ) && propertyCount )
15886 {
15887 structureChains.resize( propertyCount );
15888 properties.resize( propertyCount );
15889 for ( uint32_t i = 0; i < propertyCount; i++ )
15890 {
15891 properties[i].pNext = structureChains[i].template get<DisplayModeProperties2KHR>().pNext;
15892 }
15893 result = static_cast<Result>( d.vkGetDisplayModeProperties2KHR(
15894 m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, reinterpret_cast<VkDisplayModeProperties2KHR *>( properties.data() ) ) );
15895 }
15896 } while ( result == Result::eIncomplete );
15897 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayModeProperties2KHR" );
15898 VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
15899 if ( propertyCount < properties.size() )
15900 {
15901 structureChains.resize( propertyCount );
15902 }
15903 for ( uint32_t i = 0; i < propertyCount; i++ )
15904 {
15905 structureChains[i].template get<DisplayModeProperties2KHR>() = properties[i];
15906 }
15907 return detail::createResultValueType( result, std::move( structureChains ) );
15908 }
15909 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15910
15911 // wrapper function for command vkGetDisplayPlaneCapabilities2KHR, see
15912 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneCapabilities2KHR.html
15913 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
15914 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlaneCapabilities2KHR( const DisplayPlaneInfo2KHR * pDisplayPlaneInfo,
15915 DisplayPlaneCapabilities2KHR * pCapabilities,
15916 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
15917 {
15918 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
15919 return static_cast<Result>( d.vkGetDisplayPlaneCapabilities2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
15920 reinterpret_cast<const VkDisplayPlaneInfo2KHR *>( pDisplayPlaneInfo ),
15921 reinterpret_cast<VkDisplayPlaneCapabilities2KHR *>( pCapabilities ) ) );
15922 }
15923
15924 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15925 // wrapper function for command vkGetDisplayPlaneCapabilities2KHR, see
15926 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneCapabilities2KHR.html
15927 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
15928 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<DisplayPlaneCapabilities2KHR>::type
15929 PhysicalDevice::getDisplayPlaneCapabilities2KHR( const DisplayPlaneInfo2KHR & displayPlaneInfo, Dispatch const & d ) const
15930 {
15931 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
15932 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
15933 VULKAN_HPP_ASSERT( d.vkGetDisplayPlaneCapabilities2KHR && "Function <vkGetDisplayPlaneCapabilities2KHR> requires <VK_KHR_get_display_properties2>" );
15934 # endif
15935
15936 DisplayPlaneCapabilities2KHR capabilities;
15937 Result result = static_cast<Result>( d.vkGetDisplayPlaneCapabilities2KHR( m_physicalDevice,
15938 reinterpret_cast<const VkDisplayPlaneInfo2KHR *>( &displayPlaneInfo ),
15939 reinterpret_cast<VkDisplayPlaneCapabilities2KHR *>( &capabilities ) ) );
15940 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneCapabilities2KHR" );
15941
15942 return detail::createResultValueType( result, std::move( capabilities ) );
15943 }
15944 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15945
15946 #if defined( VK_USE_PLATFORM_IOS_MVK )
15947 //=== VK_MVK_ios_surface ===
15948
15949 // wrapper function for command vkCreateIOSSurfaceMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIOSSurfaceMVK.html
15950 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
15951 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createIOSSurfaceMVK( const IOSSurfaceCreateInfoMVK * pCreateInfo,
15952 const AllocationCallbacks * pAllocator,
15953 SurfaceKHR * pSurface,
15954 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
15955 {
15956 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
15957 return static_cast<Result>( d.vkCreateIOSSurfaceMVK( static_cast<VkInstance>( m_instance ),
15958 reinterpret_cast<const VkIOSSurfaceCreateInfoMVK *>( pCreateInfo ),
15959 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
15960 reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) );
15961 }
15962
15963 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15964 // wrapper function for command vkCreateIOSSurfaceMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIOSSurfaceMVK.html
15965 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
15966 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<SurfaceKHR>::type
15967 Instance::createIOSSurfaceMVK( const IOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
15968 {
15969 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
15970 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
15971 VULKAN_HPP_ASSERT( d.vkCreateIOSSurfaceMVK && "Function <vkCreateIOSSurfaceMVK> requires <VK_MVK_ios_surface>" );
15972 # endif
15973
15974 SurfaceKHR surface;
15975 Result result = static_cast<Result>( d.vkCreateIOSSurfaceMVK( m_instance,
15976 reinterpret_cast<const VkIOSSurfaceCreateInfoMVK *>( &createInfo ),
15977 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
15978 reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
15979 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createIOSSurfaceMVK" );
15980
15981 return detail::createResultValueType( result, std::move( surface ) );
15982 }
15983
15984 # ifndef VULKAN_HPP_NO_SMART_HANDLE
15985 // wrapper function for command vkCreateIOSSurfaceMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIOSSurfaceMVK.html
15986 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
15987 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
15988 Instance::createIOSSurfaceMVKUnique( const IOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
15989 {
15990 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
15991 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
15992 VULKAN_HPP_ASSERT( d.vkCreateIOSSurfaceMVK && "Function <vkCreateIOSSurfaceMVK> requires <VK_MVK_ios_surface>" );
15993 # endif
15994
15995 SurfaceKHR surface;
15996 Result result = static_cast<Result>( d.vkCreateIOSSurfaceMVK( m_instance,
15997 reinterpret_cast<const VkIOSSurfaceCreateInfoMVK *>( &createInfo ),
15998 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
15999 reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
16000 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createIOSSurfaceMVKUnique" );
16001
16002 return detail::createResultValueType( result,
16003 UniqueHandle<SurfaceKHR, Dispatch>( surface, detail::ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) );
16004 }
16005 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
16006 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16007 #endif /*VK_USE_PLATFORM_IOS_MVK*/
16008
16009 #if defined( VK_USE_PLATFORM_MACOS_MVK )
16010 //=== VK_MVK_macos_surface ===
16011
16012 // wrapper function for command vkCreateMacOSSurfaceMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMacOSSurfaceMVK.html
16013 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
16014 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createMacOSSurfaceMVK( const MacOSSurfaceCreateInfoMVK * pCreateInfo,
16015 const AllocationCallbacks * pAllocator,
16016 SurfaceKHR * pSurface,
16017 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
16018 {
16019 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
16020 return static_cast<Result>( d.vkCreateMacOSSurfaceMVK( static_cast<VkInstance>( m_instance ),
16021 reinterpret_cast<const VkMacOSSurfaceCreateInfoMVK *>( pCreateInfo ),
16022 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
16023 reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) );
16024 }
16025
16026 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16027 // wrapper function for command vkCreateMacOSSurfaceMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMacOSSurfaceMVK.html
16028 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
16029 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<SurfaceKHR>::type
16030 Instance::createMacOSSurfaceMVK( const MacOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
16031 {
16032 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
16033 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
16034 VULKAN_HPP_ASSERT( d.vkCreateMacOSSurfaceMVK && "Function <vkCreateMacOSSurfaceMVK> requires <VK_MVK_macos_surface>" );
16035 # endif
16036
16037 SurfaceKHR surface;
16038 Result result = static_cast<Result>( d.vkCreateMacOSSurfaceMVK( m_instance,
16039 reinterpret_cast<const VkMacOSSurfaceCreateInfoMVK *>( &createInfo ),
16040 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
16041 reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
16042 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createMacOSSurfaceMVK" );
16043
16044 return detail::createResultValueType( result, std::move( surface ) );
16045 }
16046
16047 # ifndef VULKAN_HPP_NO_SMART_HANDLE
16048 // wrapper function for command vkCreateMacOSSurfaceMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMacOSSurfaceMVK.html
16049 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
16050 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type Instance::createMacOSSurfaceMVKUnique(
16051 const MacOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
16052 {
16053 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
16054 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
16055 VULKAN_HPP_ASSERT( d.vkCreateMacOSSurfaceMVK && "Function <vkCreateMacOSSurfaceMVK> requires <VK_MVK_macos_surface>" );
16056 # endif
16057
16058 SurfaceKHR surface;
16059 Result result = static_cast<Result>( d.vkCreateMacOSSurfaceMVK( m_instance,
16060 reinterpret_cast<const VkMacOSSurfaceCreateInfoMVK *>( &createInfo ),
16061 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
16062 reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
16063 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createMacOSSurfaceMVKUnique" );
16064
16065 return detail::createResultValueType( result,
16066 UniqueHandle<SurfaceKHR, Dispatch>( surface, detail::ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) );
16067 }
16068 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
16069 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16070 #endif /*VK_USE_PLATFORM_MACOS_MVK*/
16071
16072 //=== VK_EXT_debug_utils ===
16073
16074 // wrapper function for command vkSetDebugUtilsObjectNameEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDebugUtilsObjectNameEXT.html
16075 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
16076 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::setDebugUtilsObjectNameEXT( const DebugUtilsObjectNameInfoEXT * pNameInfo,
16077 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
16078 {
16079 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
16080 return static_cast<Result>(
16081 d.vkSetDebugUtilsObjectNameEXT( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkDebugUtilsObjectNameInfoEXT *>( pNameInfo ) ) );
16082 }
16083
16084 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16085 // wrapper function for command vkSetDebugUtilsObjectNameEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDebugUtilsObjectNameEXT.html
16086 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
16087 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
16088 Device::setDebugUtilsObjectNameEXT( const DebugUtilsObjectNameInfoEXT & nameInfo, Dispatch const & d ) const
16089 {
16090 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
16091 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
16092 VULKAN_HPP_ASSERT( d.vkSetDebugUtilsObjectNameEXT && "Function <vkSetDebugUtilsObjectNameEXT> requires <VK_EXT_debug_utils>" );
16093 # endif
16094
16095 Result result = static_cast<Result>( d.vkSetDebugUtilsObjectNameEXT( m_device, reinterpret_cast<const VkDebugUtilsObjectNameInfoEXT *>( &nameInfo ) ) );
16096 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setDebugUtilsObjectNameEXT" );
16097
16098 return detail::createResultValueType( result );
16099 }
16100
16101 // wrapper function for command vkSetDebugUtilsObjectNameEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDebugUtilsObjectNameEXT.html
16102 template <typename HandleType, typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
16103 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
16104 Device::setDebugUtilsObjectNameEXT( HandleType const & handle, std::string const & name, Dispatch const & d ) const
16105 {
16106 VULKAN_HPP_STATIC_ASSERT( VULKAN_HPP_NAMESPACE::isVulkanHandleType<HandleType>::value, "HandleType must be a Vulkan handle type" );
16107 // It might be, that neither constructors, nor setters, nor designated initializers are available... need to explicitly set member by member
16108 VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT nameInfo;
16109 nameInfo.objectType = handle.objectType;
16110 nameInfo.objectHandle = reinterpret_cast<uint64_t>( static_cast<typename HandleType::CType>( handle ) );
16111 nameInfo.pObjectName = name.c_str();
16112 return setDebugUtilsObjectNameEXT( nameInfo, d );
16113 }
16114 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16115
16116 // wrapper function for command vkSetDebugUtilsObjectTagEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDebugUtilsObjectTagEXT.html
16117 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
16118 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::setDebugUtilsObjectTagEXT( const DebugUtilsObjectTagInfoEXT * pTagInfo,
16119 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
16120 {
16121 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
16122 return static_cast<Result>(
16123 d.vkSetDebugUtilsObjectTagEXT( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkDebugUtilsObjectTagInfoEXT *>( pTagInfo ) ) );
16124 }
16125
16126 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16127 // wrapper function for command vkSetDebugUtilsObjectTagEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDebugUtilsObjectTagEXT.html
16128 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
16129 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
16130 Device::setDebugUtilsObjectTagEXT( const DebugUtilsObjectTagInfoEXT & tagInfo, Dispatch const & d ) const
16131 {
16132 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
16133 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
16134 VULKAN_HPP_ASSERT( d.vkSetDebugUtilsObjectTagEXT && "Function <vkSetDebugUtilsObjectTagEXT> requires <VK_EXT_debug_utils>" );
16135 # endif
16136
16137 Result result = static_cast<Result>( d.vkSetDebugUtilsObjectTagEXT( m_device, reinterpret_cast<const VkDebugUtilsObjectTagInfoEXT *>( &tagInfo ) ) );
16138 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setDebugUtilsObjectTagEXT" );
16139
16140 return detail::createResultValueType( result );
16141 }
16142
16143 // wrapper function for command vkSetDebugUtilsObjectTagEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDebugUtilsObjectTagEXT.html
16144 template <typename HandleType, typename TagType, typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
16145 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
16146 Device::setDebugUtilsObjectTagEXT( HandleType const & handle, uint64_t name, TagType const & tag, Dispatch const & d ) const
16147 {
16148 VULKAN_HPP_STATIC_ASSERT( VULKAN_HPP_NAMESPACE::isVulkanHandleType<HandleType>::value, "HandleType must be a Vulkan handle type" );
16149 // It might be, that neither constructors, nor setters, nor designated initializers are available... need to explicitly set member by member
16150 VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT tagInfo;
16151 tagInfo.objectType = handle.objectType;
16152 tagInfo.objectHandle = reinterpret_cast<uint64_t>( static_cast<typename HandleType::CType>( handle ) );
16153 tagInfo.tagName = name;
16154 tagInfo.tagSize = sizeof( TagType );
16155 tagInfo.pTag = &tag;
16156 return setDebugUtilsObjectTagEXT( tagInfo, d );
16157 }
16158 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16159
16160 // wrapper function for command vkQueueBeginDebugUtilsLabelEXT, see
16161 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueBeginDebugUtilsLabelEXT.html
16162 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
16163 VULKAN_HPP_INLINE void Queue::beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT * pLabelInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
16164 {
16165 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
16166 d.vkQueueBeginDebugUtilsLabelEXT( static_cast<VkQueue>( m_queue ), reinterpret_cast<const VkDebugUtilsLabelEXT *>( pLabelInfo ) );
16167 }
16168
16169 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16170 // wrapper function for command vkQueueBeginDebugUtilsLabelEXT, see
16171 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueBeginDebugUtilsLabelEXT.html
16172 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
16173 VULKAN_HPP_INLINE void Queue::beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
16174 {
16175 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
16176 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
16177 VULKAN_HPP_ASSERT( d.vkQueueBeginDebugUtilsLabelEXT && "Function <vkQueueBeginDebugUtilsLabelEXT> requires <VK_EXT_debug_utils>" );
16178 # endif
16179
16180 d.vkQueueBeginDebugUtilsLabelEXT( m_queue, reinterpret_cast<const VkDebugUtilsLabelEXT *>( &labelInfo ) );
16181 }
16182 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16183
16184 // wrapper function for command vkQueueEndDebugUtilsLabelEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueEndDebugUtilsLabelEXT.html
16185 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
16186 VULKAN_HPP_INLINE void Queue::endDebugUtilsLabelEXT( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
16187 {
16188 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
16189 d.vkQueueEndDebugUtilsLabelEXT( static_cast<VkQueue>( m_queue ) );
16190 }
16191
16192 // wrapper function for command vkQueueInsertDebugUtilsLabelEXT, see
16193 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueInsertDebugUtilsLabelEXT.html
16194 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
16195 VULKAN_HPP_INLINE void Queue::insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT * pLabelInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
16196 {
16197 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
16198 d.vkQueueInsertDebugUtilsLabelEXT( static_cast<VkQueue>( m_queue ), reinterpret_cast<const VkDebugUtilsLabelEXT *>( pLabelInfo ) );
16199 }
16200
16201 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16202 // wrapper function for command vkQueueInsertDebugUtilsLabelEXT, see
16203 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueInsertDebugUtilsLabelEXT.html
16204 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
16205 VULKAN_HPP_INLINE void Queue::insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
16206 {
16207 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
16208 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
16209 VULKAN_HPP_ASSERT( d.vkQueueInsertDebugUtilsLabelEXT && "Function <vkQueueInsertDebugUtilsLabelEXT> requires <VK_EXT_debug_utils>" );
16210 # endif
16211
16212 d.vkQueueInsertDebugUtilsLabelEXT( m_queue, reinterpret_cast<const VkDebugUtilsLabelEXT *>( &labelInfo ) );
16213 }
16214 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16215
16216 // wrapper function for command vkCmdBeginDebugUtilsLabelEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginDebugUtilsLabelEXT.html
16217 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
16218 VULKAN_HPP_INLINE void CommandBuffer::beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT * pLabelInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
16219 {
16220 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
16221 d.vkCmdBeginDebugUtilsLabelEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkDebugUtilsLabelEXT *>( pLabelInfo ) );
16222 }
16223
16224 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16225 // wrapper function for command vkCmdBeginDebugUtilsLabelEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginDebugUtilsLabelEXT.html
16226 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
16227 VULKAN_HPP_INLINE void CommandBuffer::beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
16228 {
16229 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
16230 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
16231 VULKAN_HPP_ASSERT( d.vkCmdBeginDebugUtilsLabelEXT && "Function <vkCmdBeginDebugUtilsLabelEXT> requires <VK_EXT_debug_utils>" );
16232 # endif
16233
16234 d.vkCmdBeginDebugUtilsLabelEXT( m_commandBuffer, reinterpret_cast<const VkDebugUtilsLabelEXT *>( &labelInfo ) );
16235 }
16236 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16237
16238 // wrapper function for command vkCmdEndDebugUtilsLabelEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndDebugUtilsLabelEXT.html
16239 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
16240 VULKAN_HPP_INLINE void CommandBuffer::endDebugUtilsLabelEXT( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
16241 {
16242 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
16243 d.vkCmdEndDebugUtilsLabelEXT( static_cast<VkCommandBuffer>( m_commandBuffer ) );
16244 }
16245
16246 // wrapper function for command vkCmdInsertDebugUtilsLabelEXT, see
16247 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdInsertDebugUtilsLabelEXT.html
16248 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
16249 VULKAN_HPP_INLINE void CommandBuffer::insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT * pLabelInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
16250 {
16251 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
16252 d.vkCmdInsertDebugUtilsLabelEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkDebugUtilsLabelEXT *>( pLabelInfo ) );
16253 }
16254
16255 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16256 // wrapper function for command vkCmdInsertDebugUtilsLabelEXT, see
16257 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdInsertDebugUtilsLabelEXT.html
16258 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
16259 VULKAN_HPP_INLINE void CommandBuffer::insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
16260 {
16261 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
16262 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
16263 VULKAN_HPP_ASSERT( d.vkCmdInsertDebugUtilsLabelEXT && "Function <vkCmdInsertDebugUtilsLabelEXT> requires <VK_EXT_debug_utils>" );
16264 # endif
16265
16266 d.vkCmdInsertDebugUtilsLabelEXT( m_commandBuffer, reinterpret_cast<const VkDebugUtilsLabelEXT *>( &labelInfo ) );
16267 }
16268 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16269
16270 // wrapper function for command vkCreateDebugUtilsMessengerEXT, see
16271 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDebugUtilsMessengerEXT.html
16272 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
16273 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createDebugUtilsMessengerEXT( const DebugUtilsMessengerCreateInfoEXT * pCreateInfo,
16274 const AllocationCallbacks * pAllocator,
16275 DebugUtilsMessengerEXT * pMessenger,
16276 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
16277 {
16278 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
16279 return static_cast<Result>( d.vkCreateDebugUtilsMessengerEXT( static_cast<VkInstance>( m_instance ),
16280 reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT *>( pCreateInfo ),
16281 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
16282 reinterpret_cast<VkDebugUtilsMessengerEXT *>( pMessenger ) ) );
16283 }
16284
16285 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16286 // wrapper function for command vkCreateDebugUtilsMessengerEXT, see
16287 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDebugUtilsMessengerEXT.html
16288 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
16289 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<DebugUtilsMessengerEXT>::type Instance::createDebugUtilsMessengerEXT(
16290 const DebugUtilsMessengerCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
16291 {
16292 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
16293 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
16294 VULKAN_HPP_ASSERT( d.vkCreateDebugUtilsMessengerEXT && "Function <vkCreateDebugUtilsMessengerEXT> requires <VK_EXT_debug_utils>" );
16295 # endif
16296
16297 DebugUtilsMessengerEXT messenger;
16298 Result result = static_cast<Result>( d.vkCreateDebugUtilsMessengerEXT( m_instance,
16299 reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT *>( &createInfo ),
16300 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
16301 reinterpret_cast<VkDebugUtilsMessengerEXT *>( &messenger ) ) );
16302 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDebugUtilsMessengerEXT" );
16303
16304 return detail::createResultValueType( result, std::move( messenger ) );
16305 }
16306
16307 # ifndef VULKAN_HPP_NO_SMART_HANDLE
16308 // wrapper function for command vkCreateDebugUtilsMessengerEXT, see
16309 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDebugUtilsMessengerEXT.html
16310 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
16311 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<DebugUtilsMessengerEXT, Dispatch>>::type
16312 Instance::createDebugUtilsMessengerEXTUnique( const DebugUtilsMessengerCreateInfoEXT & createInfo,
16313 Optional<const AllocationCallbacks> allocator,
16314 Dispatch const & d ) const
16315 {
16316 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
16317 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
16318 VULKAN_HPP_ASSERT( d.vkCreateDebugUtilsMessengerEXT && "Function <vkCreateDebugUtilsMessengerEXT> requires <VK_EXT_debug_utils>" );
16319 # endif
16320
16321 DebugUtilsMessengerEXT messenger;
16322 Result result = static_cast<Result>( d.vkCreateDebugUtilsMessengerEXT( m_instance,
16323 reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT *>( &createInfo ),
16324 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
16325 reinterpret_cast<VkDebugUtilsMessengerEXT *>( &messenger ) ) );
16326 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDebugUtilsMessengerEXTUnique" );
16327
16328 return detail::createResultValueType(
16329 result, UniqueHandle<DebugUtilsMessengerEXT, Dispatch>( messenger, detail::ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) );
16330 }
16331 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
16332 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16333
16334 // wrapper function for command vkDestroyDebugUtilsMessengerEXT, see
16335 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDebugUtilsMessengerEXT.html
16336 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
16337 VULKAN_HPP_INLINE void Instance::destroyDebugUtilsMessengerEXT( DebugUtilsMessengerEXT messenger,
16338 const AllocationCallbacks * pAllocator,
16339 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
16340 {
16341 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
16342 d.vkDestroyDebugUtilsMessengerEXT( static_cast<VkInstance>( m_instance ),
16343 static_cast<VkDebugUtilsMessengerEXT>( messenger ),
16344 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
16345 }
16346
16347 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16348 // wrapper function for command vkDestroyDebugUtilsMessengerEXT, see
16349 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDebugUtilsMessengerEXT.html
16350 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
16351 VULKAN_HPP_INLINE void Instance::destroyDebugUtilsMessengerEXT( DebugUtilsMessengerEXT messenger,
16352 Optional<const AllocationCallbacks> allocator,
16353 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
16354 {
16355 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
16356 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
16357 VULKAN_HPP_ASSERT( d.vkDestroyDebugUtilsMessengerEXT && "Function <vkDestroyDebugUtilsMessengerEXT> requires <VK_EXT_debug_utils>" );
16358 # endif
16359
16360 d.vkDestroyDebugUtilsMessengerEXT(
16361 m_instance, static_cast<VkDebugUtilsMessengerEXT>( messenger ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
16362 }
16363 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16364
16365 // wrapper function for command vkDestroyDebugUtilsMessengerEXT, see
16366 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDebugUtilsMessengerEXT.html
16367 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
16368 VULKAN_HPP_INLINE void
16369 Instance::destroy( DebugUtilsMessengerEXT messenger, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
16370 {
16371 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
16372 d.vkDestroyDebugUtilsMessengerEXT( static_cast<VkInstance>( m_instance ),
16373 static_cast<VkDebugUtilsMessengerEXT>( messenger ),
16374 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
16375 }
16376
16377 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16378 // wrapper function for command vkDestroyDebugUtilsMessengerEXT, see
16379 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDebugUtilsMessengerEXT.html
16380 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
16381 VULKAN_HPP_INLINE void
16382 Instance::destroy( DebugUtilsMessengerEXT messenger, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
16383 {
16384 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
16385 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
16386 VULKAN_HPP_ASSERT( d.vkDestroyDebugUtilsMessengerEXT && "Function <vkDestroyDebugUtilsMessengerEXT> requires <VK_EXT_debug_utils>" );
16387 # endif
16388
16389 d.vkDestroyDebugUtilsMessengerEXT(
16390 m_instance, static_cast<VkDebugUtilsMessengerEXT>( messenger ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
16391 }
16392 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16393
16394 // wrapper function for command vkSubmitDebugUtilsMessageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSubmitDebugUtilsMessageEXT.html
16395 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
16396 VULKAN_HPP_INLINE void Instance::submitDebugUtilsMessageEXT( DebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
16397 DebugUtilsMessageTypeFlagsEXT messageTypes,
16398 const DebugUtilsMessengerCallbackDataEXT * pCallbackData,
16399 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
16400 {
16401 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
16402 d.vkSubmitDebugUtilsMessageEXT( static_cast<VkInstance>( m_instance ),
16403 static_cast<VkDebugUtilsMessageSeverityFlagBitsEXT>( messageSeverity ),
16404 static_cast<VkDebugUtilsMessageTypeFlagsEXT>( messageTypes ),
16405 reinterpret_cast<const VkDebugUtilsMessengerCallbackDataEXT *>( pCallbackData ) );
16406 }
16407
16408 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16409 // wrapper function for command vkSubmitDebugUtilsMessageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSubmitDebugUtilsMessageEXT.html
16410 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
16411 VULKAN_HPP_INLINE void Instance::submitDebugUtilsMessageEXT( DebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
16412 DebugUtilsMessageTypeFlagsEXT messageTypes,
16413 const DebugUtilsMessengerCallbackDataEXT & callbackData,
16414 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
16415 {
16416 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
16417 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
16418 VULKAN_HPP_ASSERT( d.vkSubmitDebugUtilsMessageEXT && "Function <vkSubmitDebugUtilsMessageEXT> requires <VK_EXT_debug_utils>" );
16419 # endif
16420
16421 d.vkSubmitDebugUtilsMessageEXT( m_instance,
16422 static_cast<VkDebugUtilsMessageSeverityFlagBitsEXT>( messageSeverity ),
16423 static_cast<VkDebugUtilsMessageTypeFlagsEXT>( messageTypes ),
16424 reinterpret_cast<const VkDebugUtilsMessengerCallbackDataEXT *>( &callbackData ) );
16425 }
16426 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16427
16428 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
16429 //=== VK_ANDROID_external_memory_android_hardware_buffer ===
16430
16431 // wrapper function for command vkGetAndroidHardwareBufferPropertiesANDROID, see
16432 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAndroidHardwareBufferPropertiesANDROID.html
16433 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
16434 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer * buffer,
16435 AndroidHardwareBufferPropertiesANDROID * pProperties,
16436 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
16437 {
16438 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
16439 return static_cast<Result>( d.vkGetAndroidHardwareBufferPropertiesANDROID(
16440 static_cast<VkDevice>( m_device ), buffer, reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID *>( pProperties ) ) );
16441 }
16442
16443 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16444 // wrapper function for command vkGetAndroidHardwareBufferPropertiesANDROID, see
16445 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAndroidHardwareBufferPropertiesANDROID.html
16446 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
16447 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<AndroidHardwareBufferPropertiesANDROID>::type
16448 Device::getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const & d ) const
16449 {
16450 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
16451 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
16452 VULKAN_HPP_ASSERT( d.vkGetAndroidHardwareBufferPropertiesANDROID &&
16453 "Function <vkGetAndroidHardwareBufferPropertiesANDROID> requires <VK_ANDROID_external_memory_android_hardware_buffer>" );
16454 # endif
16455
16456 AndroidHardwareBufferPropertiesANDROID properties;
16457 Result result = static_cast<Result>(
16458 d.vkGetAndroidHardwareBufferPropertiesANDROID( m_device, &buffer, reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID *>( &properties ) ) );
16459 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getAndroidHardwareBufferPropertiesANDROID" );
16460
16461 return detail::createResultValueType( result, std::move( properties ) );
16462 }
16463
16464 // wrapper function for command vkGetAndroidHardwareBufferPropertiesANDROID, see
16465 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAndroidHardwareBufferPropertiesANDROID.html
16466 template <typename X, typename Y, typename... Z, typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
16467 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<StructureChain<X, Y, Z...>>::type
16468 Device::getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const & d ) const
16469 {
16470 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
16471 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
16472 VULKAN_HPP_ASSERT( d.vkGetAndroidHardwareBufferPropertiesANDROID &&
16473 "Function <vkGetAndroidHardwareBufferPropertiesANDROID> requires <VK_ANDROID_external_memory_android_hardware_buffer>" );
16474 # endif
16475
16476 StructureChain<X, Y, Z...> structureChain;
16477 AndroidHardwareBufferPropertiesANDROID & properties = structureChain.template get<AndroidHardwareBufferPropertiesANDROID>();
16478 Result result = static_cast<Result>(
16479 d.vkGetAndroidHardwareBufferPropertiesANDROID( m_device, &buffer, reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID *>( &properties ) ) );
16480 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getAndroidHardwareBufferPropertiesANDROID" );
16481
16482 return detail::createResultValueType( result, std::move( structureChain ) );
16483 }
16484 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16485
16486 // wrapper function for command vkGetMemoryAndroidHardwareBufferANDROID, see
16487 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryAndroidHardwareBufferANDROID.html
16488 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
16489 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getMemoryAndroidHardwareBufferANDROID( const MemoryGetAndroidHardwareBufferInfoANDROID * pInfo,
16490 struct AHardwareBuffer ** pBuffer,
16491 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
16492 {
16493 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
16494 return static_cast<Result>( d.vkGetMemoryAndroidHardwareBufferANDROID(
16495 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkMemoryGetAndroidHardwareBufferInfoANDROID *>( pInfo ), pBuffer ) );
16496 }
16497
16498 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16499 // wrapper function for command vkGetMemoryAndroidHardwareBufferANDROID, see
16500 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryAndroidHardwareBufferANDROID.html
16501 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
16502 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<struct AHardwareBuffer *>::type
16503 Device::getMemoryAndroidHardwareBufferANDROID( const MemoryGetAndroidHardwareBufferInfoANDROID & info, Dispatch const & d ) const
16504 {
16505 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
16506 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
16507 VULKAN_HPP_ASSERT( d.vkGetMemoryAndroidHardwareBufferANDROID &&
16508 "Function <vkGetMemoryAndroidHardwareBufferANDROID> requires <VK_ANDROID_external_memory_android_hardware_buffer>" );
16509 # endif
16510
16511 struct AHardwareBuffer * buffer;
16512 Result result = static_cast<Result>(
16513 d.vkGetMemoryAndroidHardwareBufferANDROID( m_device, reinterpret_cast<const VkMemoryGetAndroidHardwareBufferInfoANDROID *>( &info ), &buffer ) );
16514 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryAndroidHardwareBufferANDROID" );
16515
16516 return detail::createResultValueType( result, std::move( buffer ) );
16517 }
16518 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16519 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
16520
16521 #if defined( VK_ENABLE_BETA_EXTENSIONS )
16522 //=== VK_AMDX_shader_enqueue ===
16523
16524 // wrapper function for command vkCreateExecutionGraphPipelinesAMDX, see
16525 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExecutionGraphPipelinesAMDX.html
16526 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
16527 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createExecutionGraphPipelinesAMDX( PipelineCache pipelineCache,
16528 uint32_t createInfoCount,
16529 const ExecutionGraphPipelineCreateInfoAMDX * pCreateInfos,
16530 const AllocationCallbacks * pAllocator,
16531 Pipeline * pPipelines,
16532 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
16533 {
16534 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
16535 return static_cast<Result>( d.vkCreateExecutionGraphPipelinesAMDX( static_cast<VkDevice>( m_device ),
16536 static_cast<VkPipelineCache>( pipelineCache ),
16537 createInfoCount,
16538 reinterpret_cast<const VkExecutionGraphPipelineCreateInfoAMDX *>( pCreateInfos ),
16539 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
16540 reinterpret_cast<VkPipeline *>( pPipelines ) ) );
16541 }
16542
16543 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16544 // wrapper function for command vkCreateExecutionGraphPipelinesAMDX, see
16545 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExecutionGraphPipelinesAMDX.html
16546 template <typename PipelineAllocator,
16547 typename Dispatch,
16548 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, Pipeline>::value, int>::type,
16549 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
16550 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<Pipeline, PipelineAllocator>>
16551 Device::createExecutionGraphPipelinesAMDX( PipelineCache pipelineCache,
16552 ArrayProxy<const ExecutionGraphPipelineCreateInfoAMDX> const & createInfos,
16553 Optional<const AllocationCallbacks> allocator,
16554 Dispatch const & d ) const
16555 {
16556 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
16557 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
16558 VULKAN_HPP_ASSERT( d.vkCreateExecutionGraphPipelinesAMDX && "Function <vkCreateExecutionGraphPipelinesAMDX> requires <VK_AMDX_shader_enqueue>" );
16559 # endif
16560
16561 std::vector<Pipeline, PipelineAllocator> pipelines( createInfos.size() );
16562 Result result =
16563 static_cast<Result>( d.vkCreateExecutionGraphPipelinesAMDX( m_device,
16564 static_cast<VkPipelineCache>( pipelineCache ),
16565 createInfos.size(),
16566 reinterpret_cast<const VkExecutionGraphPipelineCreateInfoAMDX *>( createInfos.data() ),
16567 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
16568 reinterpret_cast<VkPipeline *>( pipelines.data() ) ) );
16569 detail::resultCheck(
16570 result, VULKAN_HPP_NAMESPACE_STRING "::Device::createExecutionGraphPipelinesAMDX", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } );
16571
16572 return ResultValue<std::vector<Pipeline, PipelineAllocator>>( result, std::move( pipelines ) );
16573 }
16574
16575 // wrapper function for command vkCreateExecutionGraphPipelinesAMDX, see
16576 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExecutionGraphPipelinesAMDX.html
16577 template <typename PipelineAllocator,
16578 typename Dispatch,
16579 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, Pipeline>::value, int>::type,
16580 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
16581 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<Pipeline, PipelineAllocator>>
16582 Device::createExecutionGraphPipelinesAMDX( PipelineCache pipelineCache,
16583 ArrayProxy<const ExecutionGraphPipelineCreateInfoAMDX> const & createInfos,
16584 Optional<const AllocationCallbacks> allocator,
16585 PipelineAllocator & pipelineAllocator,
16586 Dispatch const & d ) const
16587 {
16588 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
16589 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
16590 VULKAN_HPP_ASSERT( d.vkCreateExecutionGraphPipelinesAMDX && "Function <vkCreateExecutionGraphPipelinesAMDX> requires <VK_AMDX_shader_enqueue>" );
16591 # endif
16592
16593 std::vector<Pipeline, PipelineAllocator> pipelines( createInfos.size(), pipelineAllocator );
16594 Result result =
16595 static_cast<Result>( d.vkCreateExecutionGraphPipelinesAMDX( m_device,
16596 static_cast<VkPipelineCache>( pipelineCache ),
16597 createInfos.size(),
16598 reinterpret_cast<const VkExecutionGraphPipelineCreateInfoAMDX *>( createInfos.data() ),
16599 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
16600 reinterpret_cast<VkPipeline *>( pipelines.data() ) ) );
16601 detail::resultCheck(
16602 result, VULKAN_HPP_NAMESPACE_STRING "::Device::createExecutionGraphPipelinesAMDX", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } );
16603
16604 return ResultValue<std::vector<Pipeline, PipelineAllocator>>( result, std::move( pipelines ) );
16605 }
16606
16607 // wrapper function for command vkCreateExecutionGraphPipelinesAMDX, see
16608 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExecutionGraphPipelinesAMDX.html
16609 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
16610 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<Pipeline>
16611 Device::createExecutionGraphPipelineAMDX( PipelineCache pipelineCache,
16612 const ExecutionGraphPipelineCreateInfoAMDX & createInfo,
16613 Optional<const AllocationCallbacks> allocator,
16614 Dispatch const & d ) const
16615 {
16616 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
16617 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
16618 VULKAN_HPP_ASSERT( d.vkCreateExecutionGraphPipelinesAMDX && "Function <vkCreateExecutionGraphPipelinesAMDX> requires <VK_AMDX_shader_enqueue>" );
16619 # endif
16620
16621 Pipeline pipeline;
16622 Result result = static_cast<Result>( d.vkCreateExecutionGraphPipelinesAMDX( m_device,
16623 static_cast<VkPipelineCache>( pipelineCache ),
16624 1,
16625 reinterpret_cast<const VkExecutionGraphPipelineCreateInfoAMDX *>( &createInfo ),
16626 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
16627 reinterpret_cast<VkPipeline *>( &pipeline ) ) );
16628 detail::resultCheck(
16629 result, VULKAN_HPP_NAMESPACE_STRING "::Device::createExecutionGraphPipelineAMDX", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } );
16630
16631 return ResultValue<Pipeline>( result, std::move( pipeline ) );
16632 }
16633
16634 # ifndef VULKAN_HPP_NO_SMART_HANDLE
16635 // wrapper function for command vkCreateExecutionGraphPipelinesAMDX, see
16636 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExecutionGraphPipelinesAMDX.html
16637 template <typename Dispatch,
16638 typename PipelineAllocator,
16639 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<Pipeline, Dispatch>>::value, int>::type,
16640 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
16641 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
16642 Device::createExecutionGraphPipelinesAMDXUnique( PipelineCache pipelineCache,
16643 ArrayProxy<const ExecutionGraphPipelineCreateInfoAMDX> const & createInfos,
16644 Optional<const AllocationCallbacks> allocator,
16645 Dispatch const & d ) const
16646 {
16647 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
16648 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
16649 VULKAN_HPP_ASSERT( d.vkCreateExecutionGraphPipelinesAMDX && "Function <vkCreateExecutionGraphPipelinesAMDX> requires <VK_AMDX_shader_enqueue>" );
16650 # endif
16651
16652 std::vector<Pipeline> pipelines( createInfos.size() );
16653 Result result =
16654 static_cast<Result>( d.vkCreateExecutionGraphPipelinesAMDX( m_device,
16655 static_cast<VkPipelineCache>( pipelineCache ),
16656 createInfos.size(),
16657 reinterpret_cast<const VkExecutionGraphPipelineCreateInfoAMDX *>( createInfos.data() ),
16658 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
16659 reinterpret_cast<VkPipeline *>( pipelines.data() ) ) );
16660 detail::resultCheck(
16661 result, VULKAN_HPP_NAMESPACE_STRING "::Device::createExecutionGraphPipelinesAMDXUnique", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } );
16662 std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator> uniquePipelines;
16663 uniquePipelines.reserve( createInfos.size() );
16664 detail::ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
16665 for ( auto const & pipeline : pipelines )
16666 {
16667 uniquePipelines.push_back( UniqueHandle<Pipeline, Dispatch>( pipeline, deleter ) );
16668 }
16669 return ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>( result, std::move( uniquePipelines ) );
16670 }
16671
16672 // wrapper function for command vkCreateExecutionGraphPipelinesAMDX, see
16673 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExecutionGraphPipelinesAMDX.html
16674 template <typename Dispatch,
16675 typename PipelineAllocator,
16676 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<Pipeline, Dispatch>>::value, int>::type,
16677 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
16678 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
16679 Device::createExecutionGraphPipelinesAMDXUnique( PipelineCache pipelineCache,
16680 ArrayProxy<const ExecutionGraphPipelineCreateInfoAMDX> const & createInfos,
16681 Optional<const AllocationCallbacks> allocator,
16682 PipelineAllocator & pipelineAllocator,
16683 Dispatch const & d ) const
16684 {
16685 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
16686 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
16687 VULKAN_HPP_ASSERT( d.vkCreateExecutionGraphPipelinesAMDX && "Function <vkCreateExecutionGraphPipelinesAMDX> requires <VK_AMDX_shader_enqueue>" );
16688 # endif
16689
16690 std::vector<Pipeline> pipelines( createInfos.size() );
16691 Result result =
16692 static_cast<Result>( d.vkCreateExecutionGraphPipelinesAMDX( m_device,
16693 static_cast<VkPipelineCache>( pipelineCache ),
16694 createInfos.size(),
16695 reinterpret_cast<const VkExecutionGraphPipelineCreateInfoAMDX *>( createInfos.data() ),
16696 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
16697 reinterpret_cast<VkPipeline *>( pipelines.data() ) ) );
16698 detail::resultCheck(
16699 result, VULKAN_HPP_NAMESPACE_STRING "::Device::createExecutionGraphPipelinesAMDXUnique", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } );
16700 std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator> uniquePipelines( pipelineAllocator );
16701 uniquePipelines.reserve( createInfos.size() );
16702 detail::ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
16703 for ( auto const & pipeline : pipelines )
16704 {
16705 uniquePipelines.push_back( UniqueHandle<Pipeline, Dispatch>( pipeline, deleter ) );
16706 }
16707 return ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>( result, std::move( uniquePipelines ) );
16708 }
16709
16710 // wrapper function for command vkCreateExecutionGraphPipelinesAMDX, see
16711 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExecutionGraphPipelinesAMDX.html
16712 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
16713 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<UniqueHandle<Pipeline, Dispatch>>
16714 Device::createExecutionGraphPipelineAMDXUnique( PipelineCache pipelineCache,
16715 const ExecutionGraphPipelineCreateInfoAMDX & createInfo,
16716 Optional<const AllocationCallbacks> allocator,
16717 Dispatch const & d ) const
16718 {
16719 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
16720 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
16721 VULKAN_HPP_ASSERT( d.vkCreateExecutionGraphPipelinesAMDX && "Function <vkCreateExecutionGraphPipelinesAMDX> requires <VK_AMDX_shader_enqueue>" );
16722 # endif
16723
16724 Pipeline pipeline;
16725 Result result = static_cast<Result>( d.vkCreateExecutionGraphPipelinesAMDX( m_device,
16726 static_cast<VkPipelineCache>( pipelineCache ),
16727 1,
16728 reinterpret_cast<const VkExecutionGraphPipelineCreateInfoAMDX *>( &createInfo ),
16729 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
16730 reinterpret_cast<VkPipeline *>( &pipeline ) ) );
16731 detail::resultCheck(
16732 result, VULKAN_HPP_NAMESPACE_STRING "::Device::createExecutionGraphPipelineAMDXUnique", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } );
16733
16734 return ResultValue<UniqueHandle<Pipeline, Dispatch>>(
16735 result, UniqueHandle<Pipeline, Dispatch>( pipeline, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
16736 }
16737 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
16738 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16739
16740 // wrapper function for command vkGetExecutionGraphPipelineScratchSizeAMDX, see
16741 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExecutionGraphPipelineScratchSizeAMDX.html
16742 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
16743 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getExecutionGraphPipelineScratchSizeAMDX( Pipeline executionGraph,
16744 ExecutionGraphPipelineScratchSizeAMDX * pSizeInfo,
16745 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
16746 {
16747 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
16748 return static_cast<Result>( d.vkGetExecutionGraphPipelineScratchSizeAMDX( static_cast<VkDevice>( m_device ),
16749 static_cast<VkPipeline>( executionGraph ),
16750 reinterpret_cast<VkExecutionGraphPipelineScratchSizeAMDX *>( pSizeInfo ) ) );
16751 }
16752
16753 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16754 // wrapper function for command vkGetExecutionGraphPipelineScratchSizeAMDX, see
16755 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExecutionGraphPipelineScratchSizeAMDX.html
16756 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
16757 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<ExecutionGraphPipelineScratchSizeAMDX>::type
16758 Device::getExecutionGraphPipelineScratchSizeAMDX( Pipeline executionGraph, Dispatch const & d ) const
16759 {
16760 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
16761 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
16762 VULKAN_HPP_ASSERT( d.vkGetExecutionGraphPipelineScratchSizeAMDX &&
16763 "Function <vkGetExecutionGraphPipelineScratchSizeAMDX> requires <VK_AMDX_shader_enqueue>" );
16764 # endif
16765
16766 ExecutionGraphPipelineScratchSizeAMDX sizeInfo;
16767 Result result = static_cast<Result>( d.vkGetExecutionGraphPipelineScratchSizeAMDX(
16768 m_device, static_cast<VkPipeline>( executionGraph ), reinterpret_cast<VkExecutionGraphPipelineScratchSizeAMDX *>( &sizeInfo ) ) );
16769 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getExecutionGraphPipelineScratchSizeAMDX" );
16770
16771 return detail::createResultValueType( result, std::move( sizeInfo ) );
16772 }
16773 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16774
16775 // wrapper function for command vkGetExecutionGraphPipelineNodeIndexAMDX, see
16776 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExecutionGraphPipelineNodeIndexAMDX.html
16777 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
16778 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getExecutionGraphPipelineNodeIndexAMDX( Pipeline executionGraph,
16779 const PipelineShaderStageNodeCreateInfoAMDX * pNodeInfo,
16780 uint32_t * pNodeIndex,
16781 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
16782 {
16783 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
16784 return static_cast<Result>( d.vkGetExecutionGraphPipelineNodeIndexAMDX( static_cast<VkDevice>( m_device ),
16785 static_cast<VkPipeline>( executionGraph ),
16786 reinterpret_cast<const VkPipelineShaderStageNodeCreateInfoAMDX *>( pNodeInfo ),
16787 pNodeIndex ) );
16788 }
16789
16790 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16791 // wrapper function for command vkGetExecutionGraphPipelineNodeIndexAMDX, see
16792 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExecutionGraphPipelineNodeIndexAMDX.html
16793 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
16794 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<uint32_t>::type
16795 Device::getExecutionGraphPipelineNodeIndexAMDX( Pipeline executionGraph, const PipelineShaderStageNodeCreateInfoAMDX & nodeInfo, Dispatch const & d ) const
16796 {
16797 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
16798 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
16799 VULKAN_HPP_ASSERT( d.vkGetExecutionGraphPipelineNodeIndexAMDX && "Function <vkGetExecutionGraphPipelineNodeIndexAMDX> requires <VK_AMDX_shader_enqueue>" );
16800 # endif
16801
16802 uint32_t nodeIndex;
16803 Result result = static_cast<Result>( d.vkGetExecutionGraphPipelineNodeIndexAMDX(
16804 m_device, static_cast<VkPipeline>( executionGraph ), reinterpret_cast<const VkPipelineShaderStageNodeCreateInfoAMDX *>( &nodeInfo ), &nodeIndex ) );
16805 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getExecutionGraphPipelineNodeIndexAMDX" );
16806
16807 return detail::createResultValueType( result, std::move( nodeIndex ) );
16808 }
16809 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16810
16811 // wrapper function for command vkCmdInitializeGraphScratchMemoryAMDX, see
16812 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdInitializeGraphScratchMemoryAMDX.html
16813 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
16814 VULKAN_HPP_INLINE void CommandBuffer::initializeGraphScratchMemoryAMDX( Pipeline executionGraph,
16815 DeviceAddress scratch,
16816 DeviceSize scratchSize,
16817 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
16818 {
16819 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
16820 d.vkCmdInitializeGraphScratchMemoryAMDX( static_cast<VkCommandBuffer>( m_commandBuffer ),
16821 static_cast<VkPipeline>( executionGraph ),
16822 static_cast<VkDeviceAddress>( scratch ),
16823 static_cast<VkDeviceSize>( scratchSize ) );
16824 }
16825
16826 // wrapper function for command vkCmdDispatchGraphAMDX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchGraphAMDX.html
16827 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
16828 VULKAN_HPP_INLINE void CommandBuffer::dispatchGraphAMDX( DeviceAddress scratch,
16829 DeviceSize scratchSize,
16830 const DispatchGraphCountInfoAMDX * pCountInfo,
16831 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
16832 {
16833 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
16834 d.vkCmdDispatchGraphAMDX( static_cast<VkCommandBuffer>( m_commandBuffer ),
16835 static_cast<VkDeviceAddress>( scratch ),
16836 static_cast<VkDeviceSize>( scratchSize ),
16837 reinterpret_cast<const VkDispatchGraphCountInfoAMDX *>( pCountInfo ) );
16838 }
16839
16840 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16841 // wrapper function for command vkCmdDispatchGraphAMDX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchGraphAMDX.html
16842 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
16843 VULKAN_HPP_INLINE void CommandBuffer::dispatchGraphAMDX( DeviceAddress scratch,
16844 DeviceSize scratchSize,
16845 const DispatchGraphCountInfoAMDX & countInfo,
16846 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
16847 {
16848 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
16849 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
16850 VULKAN_HPP_ASSERT( d.vkCmdDispatchGraphAMDX && "Function <vkCmdDispatchGraphAMDX> requires <VK_AMDX_shader_enqueue>" );
16851 # endif
16852
16853 d.vkCmdDispatchGraphAMDX( m_commandBuffer,
16854 static_cast<VkDeviceAddress>( scratch ),
16855 static_cast<VkDeviceSize>( scratchSize ),
16856 reinterpret_cast<const VkDispatchGraphCountInfoAMDX *>( &countInfo ) );
16857 }
16858 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16859
16860 // wrapper function for command vkCmdDispatchGraphIndirectAMDX, see
16861 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchGraphIndirectAMDX.html
16862 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
16863 VULKAN_HPP_INLINE void CommandBuffer::dispatchGraphIndirectAMDX( DeviceAddress scratch,
16864 DeviceSize scratchSize,
16865 const DispatchGraphCountInfoAMDX * pCountInfo,
16866 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
16867 {
16868 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
16869 d.vkCmdDispatchGraphIndirectAMDX( static_cast<VkCommandBuffer>( m_commandBuffer ),
16870 static_cast<VkDeviceAddress>( scratch ),
16871 static_cast<VkDeviceSize>( scratchSize ),
16872 reinterpret_cast<const VkDispatchGraphCountInfoAMDX *>( pCountInfo ) );
16873 }
16874
16875 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16876 // wrapper function for command vkCmdDispatchGraphIndirectAMDX, see
16877 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchGraphIndirectAMDX.html
16878 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
16879 VULKAN_HPP_INLINE void CommandBuffer::dispatchGraphIndirectAMDX( DeviceAddress scratch,
16880 DeviceSize scratchSize,
16881 const DispatchGraphCountInfoAMDX & countInfo,
16882 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
16883 {
16884 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
16885 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
16886 VULKAN_HPP_ASSERT( d.vkCmdDispatchGraphIndirectAMDX && "Function <vkCmdDispatchGraphIndirectAMDX> requires <VK_AMDX_shader_enqueue>" );
16887 # endif
16888
16889 d.vkCmdDispatchGraphIndirectAMDX( m_commandBuffer,
16890 static_cast<VkDeviceAddress>( scratch ),
16891 static_cast<VkDeviceSize>( scratchSize ),
16892 reinterpret_cast<const VkDispatchGraphCountInfoAMDX *>( &countInfo ) );
16893 }
16894 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16895
16896 // wrapper function for command vkCmdDispatchGraphIndirectCountAMDX, see
16897 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchGraphIndirectCountAMDX.html
16898 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
16899 VULKAN_HPP_INLINE void CommandBuffer::dispatchGraphIndirectCountAMDX( DeviceAddress scratch,
16900 DeviceSize scratchSize,
16901 DeviceAddress countInfo,
16902 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
16903 {
16904 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
16905 d.vkCmdDispatchGraphIndirectCountAMDX( static_cast<VkCommandBuffer>( m_commandBuffer ),
16906 static_cast<VkDeviceAddress>( scratch ),
16907 static_cast<VkDeviceSize>( scratchSize ),
16908 static_cast<VkDeviceAddress>( countInfo ) );
16909 }
16910 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
16911
16912 //=== VK_EXT_sample_locations ===
16913
16914 // wrapper function for command vkCmdSetSampleLocationsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetSampleLocationsEXT.html
16915 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
16916 VULKAN_HPP_INLINE void CommandBuffer::setSampleLocationsEXT( const SampleLocationsInfoEXT * pSampleLocationsInfo,
16917 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
16918 {
16919 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
16920 d.vkCmdSetSampleLocationsEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkSampleLocationsInfoEXT *>( pSampleLocationsInfo ) );
16921 }
16922
16923 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16924 // wrapper function for command vkCmdSetSampleLocationsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetSampleLocationsEXT.html
16925 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
16926 VULKAN_HPP_INLINE void CommandBuffer::setSampleLocationsEXT( const SampleLocationsInfoEXT & sampleLocationsInfo,
16927 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
16928 {
16929 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
16930 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
16931 VULKAN_HPP_ASSERT( d.vkCmdSetSampleLocationsEXT && "Function <vkCmdSetSampleLocationsEXT> requires <VK_EXT_sample_locations>" );
16932 # endif
16933
16934 d.vkCmdSetSampleLocationsEXT( m_commandBuffer, reinterpret_cast<const VkSampleLocationsInfoEXT *>( &sampleLocationsInfo ) );
16935 }
16936 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16937
16938 // wrapper function for command vkGetPhysicalDeviceMultisamplePropertiesEXT, see
16939 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMultisamplePropertiesEXT.html
16940 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
16941 VULKAN_HPP_INLINE void PhysicalDevice::getMultisamplePropertiesEXT( SampleCountFlagBits samples,
16942 MultisamplePropertiesEXT * pMultisampleProperties,
16943 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
16944 {
16945 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
16946 d.vkGetPhysicalDeviceMultisamplePropertiesEXT( static_cast<VkPhysicalDevice>( m_physicalDevice ),
16947 static_cast<VkSampleCountFlagBits>( samples ),
16948 reinterpret_cast<VkMultisamplePropertiesEXT *>( pMultisampleProperties ) );
16949 }
16950
16951 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16952 // wrapper function for command vkGetPhysicalDeviceMultisamplePropertiesEXT, see
16953 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMultisamplePropertiesEXT.html
16954 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
16955 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MultisamplePropertiesEXT PhysicalDevice::getMultisamplePropertiesEXT( SampleCountFlagBits samples,
16956 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
16957 {
16958 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
16959 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
16960 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceMultisamplePropertiesEXT &&
16961 "Function <vkGetPhysicalDeviceMultisamplePropertiesEXT> requires <VK_EXT_sample_locations>" );
16962 # endif
16963
16964 MultisamplePropertiesEXT multisampleProperties;
16965 d.vkGetPhysicalDeviceMultisamplePropertiesEXT(
16966 m_physicalDevice, static_cast<VkSampleCountFlagBits>( samples ), reinterpret_cast<VkMultisamplePropertiesEXT *>( &multisampleProperties ) );
16967
16968 return multisampleProperties;
16969 }
16970 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16971
16972 //=== VK_KHR_get_memory_requirements2 ===
16973
16974 // wrapper function for command vkGetImageMemoryRequirements2KHR, see
16975 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements2KHR.html
16976 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
16977 VULKAN_HPP_INLINE void Device::getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 * pInfo,
16978 MemoryRequirements2 * pMemoryRequirements,
16979 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
16980 {
16981 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
16982 d.vkGetImageMemoryRequirements2KHR( static_cast<VkDevice>( m_device ),
16983 reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>( pInfo ),
16984 reinterpret_cast<VkMemoryRequirements2 *>( pMemoryRequirements ) );
16985 }
16986
16987 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16988 // wrapper function for command vkGetImageMemoryRequirements2KHR, see
16989 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements2KHR.html
16990 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
16991 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 Device::getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info,
16992 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
16993 {
16994 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
16995 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
16996 VULKAN_HPP_ASSERT( d.vkGetImageMemoryRequirements2KHR &&
16997 "Function <vkGetImageMemoryRequirements2KHR> requires <VK_KHR_get_memory_requirements2> or <VK_VERSION_1_1>" );
16998 # endif
16999
17000 MemoryRequirements2 memoryRequirements;
17001 d.vkGetImageMemoryRequirements2KHR(
17002 m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>( &info ), reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
17003
17004 return memoryRequirements;
17005 }
17006
17007 // wrapper function for command vkGetImageMemoryRequirements2KHR, see
17008 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements2KHR.html
17009 template <typename X, typename Y, typename... Z, typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
17010 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info,
17011 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
17012 {
17013 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
17014 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
17015 VULKAN_HPP_ASSERT( d.vkGetImageMemoryRequirements2KHR &&
17016 "Function <vkGetImageMemoryRequirements2KHR> requires <VK_KHR_get_memory_requirements2> or <VK_VERSION_1_1>" );
17017 # endif
17018
17019 StructureChain<X, Y, Z...> structureChain;
17020 MemoryRequirements2 & memoryRequirements = structureChain.template get<MemoryRequirements2>();
17021 d.vkGetImageMemoryRequirements2KHR(
17022 m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>( &info ), reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
17023
17024 return structureChain;
17025 }
17026 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17027
17028 // wrapper function for command vkGetBufferMemoryRequirements2KHR, see
17029 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements2KHR.html
17030 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
17031 VULKAN_HPP_INLINE void Device::getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 * pInfo,
17032 MemoryRequirements2 * pMemoryRequirements,
17033 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
17034 {
17035 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
17036 d.vkGetBufferMemoryRequirements2KHR( static_cast<VkDevice>( m_device ),
17037 reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>( pInfo ),
17038 reinterpret_cast<VkMemoryRequirements2 *>( pMemoryRequirements ) );
17039 }
17040
17041 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17042 // wrapper function for command vkGetBufferMemoryRequirements2KHR, see
17043 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements2KHR.html
17044 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
17045 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 Device::getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info,
17046 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
17047 {
17048 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
17049 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
17050 VULKAN_HPP_ASSERT( d.vkGetBufferMemoryRequirements2KHR &&
17051 "Function <vkGetBufferMemoryRequirements2KHR> requires <VK_KHR_get_memory_requirements2> or <VK_VERSION_1_1>" );
17052 # endif
17053
17054 MemoryRequirements2 memoryRequirements;
17055 d.vkGetBufferMemoryRequirements2KHR(
17056 m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>( &info ), reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
17057
17058 return memoryRequirements;
17059 }
17060
17061 // wrapper function for command vkGetBufferMemoryRequirements2KHR, see
17062 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements2KHR.html
17063 template <typename X, typename Y, typename... Z, typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
17064 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info,
17065 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
17066 {
17067 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
17068 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
17069 VULKAN_HPP_ASSERT( d.vkGetBufferMemoryRequirements2KHR &&
17070 "Function <vkGetBufferMemoryRequirements2KHR> requires <VK_KHR_get_memory_requirements2> or <VK_VERSION_1_1>" );
17071 # endif
17072
17073 StructureChain<X, Y, Z...> structureChain;
17074 MemoryRequirements2 & memoryRequirements = structureChain.template get<MemoryRequirements2>();
17075 d.vkGetBufferMemoryRequirements2KHR(
17076 m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>( &info ), reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
17077
17078 return structureChain;
17079 }
17080 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17081
17082 // wrapper function for command vkGetImageSparseMemoryRequirements2KHR, see
17083 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements2KHR.html
17084 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
17085 VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 * pInfo,
17086 uint32_t * pSparseMemoryRequirementCount,
17087 SparseImageMemoryRequirements2 * pSparseMemoryRequirements,
17088 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
17089 {
17090 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
17091 d.vkGetImageSparseMemoryRequirements2KHR( static_cast<VkDevice>( m_device ),
17092 reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( pInfo ),
17093 pSparseMemoryRequirementCount,
17094 reinterpret_cast<VkSparseImageMemoryRequirements2 *>( pSparseMemoryRequirements ) );
17095 }
17096
17097 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17098 // wrapper function for command vkGetImageSparseMemoryRequirements2KHR, see
17099 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements2KHR.html
17100 template <
17101 typename SparseImageMemoryRequirements2Allocator,
17102 typename Dispatch,
17103 typename std::enable_if<std::is_same<typename SparseImageMemoryRequirements2Allocator::value_type, SparseImageMemoryRequirements2>::value, int>::type,
17104 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
17105 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
17106 Device::getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info, Dispatch const & d ) const
17107 {
17108 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
17109 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
17110 VULKAN_HPP_ASSERT( d.vkGetImageSparseMemoryRequirements2KHR &&
17111 "Function <vkGetImageSparseMemoryRequirements2KHR> requires <VK_KHR_get_memory_requirements2> or <VK_VERSION_1_1>" );
17112 # endif
17113
17114 std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> sparseMemoryRequirements;
17115 uint32_t sparseMemoryRequirementCount;
17116 d.vkGetImageSparseMemoryRequirements2KHR(
17117 m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ), &sparseMemoryRequirementCount, nullptr );
17118 sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
17119 d.vkGetImageSparseMemoryRequirements2KHR( m_device,
17120 reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ),
17121 &sparseMemoryRequirementCount,
17122 reinterpret_cast<VkSparseImageMemoryRequirements2 *>( sparseMemoryRequirements.data() ) );
17123
17124 VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() );
17125 if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() )
17126 {
17127 sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
17128 }
17129 return sparseMemoryRequirements;
17130 }
17131
17132 // wrapper function for command vkGetImageSparseMemoryRequirements2KHR, see
17133 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements2KHR.html
17134 template <
17135 typename SparseImageMemoryRequirements2Allocator,
17136 typename Dispatch,
17137 typename std::enable_if<std::is_same<typename SparseImageMemoryRequirements2Allocator::value_type, SparseImageMemoryRequirements2>::value, int>::type,
17138 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
17139 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
17140 Device::getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info,
17141 SparseImageMemoryRequirements2Allocator & sparseImageMemoryRequirements2Allocator,
17142 Dispatch const & d ) const
17143 {
17144 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
17145 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
17146 VULKAN_HPP_ASSERT( d.vkGetImageSparseMemoryRequirements2KHR &&
17147 "Function <vkGetImageSparseMemoryRequirements2KHR> requires <VK_KHR_get_memory_requirements2> or <VK_VERSION_1_1>" );
17148 # endif
17149
17150 std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> sparseMemoryRequirements( sparseImageMemoryRequirements2Allocator );
17151 uint32_t sparseMemoryRequirementCount;
17152 d.vkGetImageSparseMemoryRequirements2KHR(
17153 m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ), &sparseMemoryRequirementCount, nullptr );
17154 sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
17155 d.vkGetImageSparseMemoryRequirements2KHR( m_device,
17156 reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ),
17157 &sparseMemoryRequirementCount,
17158 reinterpret_cast<VkSparseImageMemoryRequirements2 *>( sparseMemoryRequirements.data() ) );
17159
17160 VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() );
17161 if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() )
17162 {
17163 sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
17164 }
17165 return sparseMemoryRequirements;
17166 }
17167 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17168
17169 //=== VK_KHR_acceleration_structure ===
17170
17171 // wrapper function for command vkCreateAccelerationStructureKHR, see
17172 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAccelerationStructureKHR.html
17173 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
17174 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createAccelerationStructureKHR( const AccelerationStructureCreateInfoKHR * pCreateInfo,
17175 const AllocationCallbacks * pAllocator,
17176 AccelerationStructureKHR * pAccelerationStructure,
17177 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
17178 {
17179 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
17180 return static_cast<Result>( d.vkCreateAccelerationStructureKHR( static_cast<VkDevice>( m_device ),
17181 reinterpret_cast<const VkAccelerationStructureCreateInfoKHR *>( pCreateInfo ),
17182 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
17183 reinterpret_cast<VkAccelerationStructureKHR *>( pAccelerationStructure ) ) );
17184 }
17185
17186 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17187 // wrapper function for command vkCreateAccelerationStructureKHR, see
17188 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAccelerationStructureKHR.html
17189 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
17190 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<AccelerationStructureKHR>::type Device::createAccelerationStructureKHR(
17191 const AccelerationStructureCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
17192 {
17193 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
17194 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
17195 VULKAN_HPP_ASSERT( d.vkCreateAccelerationStructureKHR && "Function <vkCreateAccelerationStructureKHR> requires <VK_KHR_acceleration_structure>" );
17196 # endif
17197
17198 AccelerationStructureKHR accelerationStructure;
17199 Result result = static_cast<Result>( d.vkCreateAccelerationStructureKHR( m_device,
17200 reinterpret_cast<const VkAccelerationStructureCreateInfoKHR *>( &createInfo ),
17201 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
17202 reinterpret_cast<VkAccelerationStructureKHR *>( &accelerationStructure ) ) );
17203 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createAccelerationStructureKHR" );
17204
17205 return detail::createResultValueType( result, std::move( accelerationStructure ) );
17206 }
17207
17208 # ifndef VULKAN_HPP_NO_SMART_HANDLE
17209 // wrapper function for command vkCreateAccelerationStructureKHR, see
17210 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAccelerationStructureKHR.html
17211 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
17212 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<AccelerationStructureKHR, Dispatch>>::type
17213 Device::createAccelerationStructureKHRUnique( const AccelerationStructureCreateInfoKHR & createInfo,
17214 Optional<const AllocationCallbacks> allocator,
17215 Dispatch const & d ) const
17216 {
17217 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
17218 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
17219 VULKAN_HPP_ASSERT( d.vkCreateAccelerationStructureKHR && "Function <vkCreateAccelerationStructureKHR> requires <VK_KHR_acceleration_structure>" );
17220 # endif
17221
17222 AccelerationStructureKHR accelerationStructure;
17223 Result result = static_cast<Result>( d.vkCreateAccelerationStructureKHR( m_device,
17224 reinterpret_cast<const VkAccelerationStructureCreateInfoKHR *>( &createInfo ),
17225 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
17226 reinterpret_cast<VkAccelerationStructureKHR *>( &accelerationStructure ) ) );
17227 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createAccelerationStructureKHRUnique" );
17228
17229 return detail::createResultValueType(
17230 result, UniqueHandle<AccelerationStructureKHR, Dispatch>( accelerationStructure, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
17231 }
17232 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
17233 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17234
17235 // wrapper function for command vkDestroyAccelerationStructureKHR, see
17236 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyAccelerationStructureKHR.html
17237 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
17238 VULKAN_HPP_INLINE void Device::destroyAccelerationStructureKHR( AccelerationStructureKHR accelerationStructure,
17239 const AllocationCallbacks * pAllocator,
17240 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
17241 {
17242 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
17243 d.vkDestroyAccelerationStructureKHR( static_cast<VkDevice>( m_device ),
17244 static_cast<VkAccelerationStructureKHR>( accelerationStructure ),
17245 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
17246 }
17247
17248 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17249 // wrapper function for command vkDestroyAccelerationStructureKHR, see
17250 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyAccelerationStructureKHR.html
17251 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
17252 VULKAN_HPP_INLINE void Device::destroyAccelerationStructureKHR( AccelerationStructureKHR accelerationStructure,
17253 Optional<const AllocationCallbacks> allocator,
17254 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
17255 {
17256 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
17257 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
17258 VULKAN_HPP_ASSERT( d.vkDestroyAccelerationStructureKHR && "Function <vkDestroyAccelerationStructureKHR> requires <VK_KHR_acceleration_structure>" );
17259 # endif
17260
17261 d.vkDestroyAccelerationStructureKHR(
17262 m_device, static_cast<VkAccelerationStructureKHR>( accelerationStructure ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
17263 }
17264 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17265
17266 // wrapper function for command vkDestroyAccelerationStructureKHR, see
17267 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyAccelerationStructureKHR.html
17268 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
17269 VULKAN_HPP_INLINE void
17270 Device::destroy( AccelerationStructureKHR accelerationStructure, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
17271 {
17272 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
17273 d.vkDestroyAccelerationStructureKHR( static_cast<VkDevice>( m_device ),
17274 static_cast<VkAccelerationStructureKHR>( accelerationStructure ),
17275 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
17276 }
17277
17278 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17279 // wrapper function for command vkDestroyAccelerationStructureKHR, see
17280 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyAccelerationStructureKHR.html
17281 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
17282 VULKAN_HPP_INLINE void Device::destroy( AccelerationStructureKHR accelerationStructure,
17283 Optional<const AllocationCallbacks> allocator,
17284 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
17285 {
17286 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
17287 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
17288 VULKAN_HPP_ASSERT( d.vkDestroyAccelerationStructureKHR && "Function <vkDestroyAccelerationStructureKHR> requires <VK_KHR_acceleration_structure>" );
17289 # endif
17290
17291 d.vkDestroyAccelerationStructureKHR(
17292 m_device, static_cast<VkAccelerationStructureKHR>( accelerationStructure ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
17293 }
17294 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17295
17296 // wrapper function for command vkCmdBuildAccelerationStructuresKHR, see
17297 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildAccelerationStructuresKHR.html
17298 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
17299 VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructuresKHR( uint32_t infoCount,
17300 const AccelerationStructureBuildGeometryInfoKHR * pInfos,
17301 const AccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos,
17302 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
17303 {
17304 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
17305 d.vkCmdBuildAccelerationStructuresKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
17306 infoCount,
17307 reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>( pInfos ),
17308 reinterpret_cast<const VkAccelerationStructureBuildRangeInfoKHR * const *>( ppBuildRangeInfos ) );
17309 }
17310
17311 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17312 // wrapper function for command vkCmdBuildAccelerationStructuresKHR, see
17313 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildAccelerationStructuresKHR.html
17314 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
17315 VULKAN_HPP_INLINE void
17316 CommandBuffer::buildAccelerationStructuresKHR( ArrayProxy<const AccelerationStructureBuildGeometryInfoKHR> const & infos,
17317 ArrayProxy<const AccelerationStructureBuildRangeInfoKHR * const> const & pBuildRangeInfos,
17318 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
17319 {
17320 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
17321 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
17322 VULKAN_HPP_ASSERT( d.vkCmdBuildAccelerationStructuresKHR && "Function <vkCmdBuildAccelerationStructuresKHR> requires <VK_KHR_acceleration_structure>" );
17323 # endif
17324 # ifdef VULKAN_HPP_NO_EXCEPTIONS
17325 VULKAN_HPP_ASSERT( infos.size() == pBuildRangeInfos.size() );
17326 # else
17327 if ( infos.size() != pBuildRangeInfos.size() )
17328 {
17329 throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::buildAccelerationStructuresKHR: infos.size() != pBuildRangeInfos.size()" );
17330 }
17331 # endif /*VULKAN_HPP_NO_EXCEPTIONS*/
17332
17333 d.vkCmdBuildAccelerationStructuresKHR( m_commandBuffer,
17334 infos.size(),
17335 reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>( infos.data() ),
17336 reinterpret_cast<const VkAccelerationStructureBuildRangeInfoKHR * const *>( pBuildRangeInfos.data() ) );
17337 }
17338 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17339
17340 // wrapper function for command vkCmdBuildAccelerationStructuresIndirectKHR, see
17341 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildAccelerationStructuresIndirectKHR.html
17342 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
17343 VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructuresIndirectKHR( uint32_t infoCount,
17344 const AccelerationStructureBuildGeometryInfoKHR * pInfos,
17345 const DeviceAddress * pIndirectDeviceAddresses,
17346 const uint32_t * pIndirectStrides,
17347 const uint32_t * const * ppMaxPrimitiveCounts,
17348 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
17349 {
17350 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
17351 d.vkCmdBuildAccelerationStructuresIndirectKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
17352 infoCount,
17353 reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>( pInfos ),
17354 reinterpret_cast<const VkDeviceAddress *>( pIndirectDeviceAddresses ),
17355 pIndirectStrides,
17356 ppMaxPrimitiveCounts );
17357 }
17358
17359 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17360 // wrapper function for command vkCmdBuildAccelerationStructuresIndirectKHR, see
17361 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildAccelerationStructuresIndirectKHR.html
17362 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
17363 VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructuresIndirectKHR( ArrayProxy<const AccelerationStructureBuildGeometryInfoKHR> const & infos,
17364 ArrayProxy<const DeviceAddress> const & indirectDeviceAddresses,
17365 ArrayProxy<const uint32_t> const & indirectStrides,
17366 ArrayProxy<const uint32_t * const> const & pMaxPrimitiveCounts,
17367 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
17368 {
17369 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
17370 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
17371 VULKAN_HPP_ASSERT( d.vkCmdBuildAccelerationStructuresIndirectKHR &&
17372 "Function <vkCmdBuildAccelerationStructuresIndirectKHR> requires <VK_KHR_acceleration_structure>" );
17373 # endif
17374 # ifdef VULKAN_HPP_NO_EXCEPTIONS
17375 VULKAN_HPP_ASSERT( infos.size() == indirectDeviceAddresses.size() );
17376 VULKAN_HPP_ASSERT( infos.size() == indirectStrides.size() );
17377 VULKAN_HPP_ASSERT( infos.size() == pMaxPrimitiveCounts.size() );
17378 # else
17379 if ( infos.size() != indirectDeviceAddresses.size() )
17380 {
17381 throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::buildAccelerationStructuresIndirectKHR: infos.size() != indirectDeviceAddresses.size()" );
17382 }
17383 if ( infos.size() != indirectStrides.size() )
17384 {
17385 throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::buildAccelerationStructuresIndirectKHR: infos.size() != indirectStrides.size()" );
17386 }
17387 if ( infos.size() != pMaxPrimitiveCounts.size() )
17388 {
17389 throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::buildAccelerationStructuresIndirectKHR: infos.size() != pMaxPrimitiveCounts.size()" );
17390 }
17391 # endif /*VULKAN_HPP_NO_EXCEPTIONS*/
17392
17393 d.vkCmdBuildAccelerationStructuresIndirectKHR( m_commandBuffer,
17394 infos.size(),
17395 reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>( infos.data() ),
17396 reinterpret_cast<const VkDeviceAddress *>( indirectDeviceAddresses.data() ),
17397 indirectStrides.data(),
17398 pMaxPrimitiveCounts.data() );
17399 }
17400 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17401
17402 // wrapper function for command vkBuildAccelerationStructuresKHR, see
17403 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBuildAccelerationStructuresKHR.html
17404 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
17405 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
17406 Device::buildAccelerationStructuresKHR( DeferredOperationKHR deferredOperation,
17407 uint32_t infoCount,
17408 const AccelerationStructureBuildGeometryInfoKHR * pInfos,
17409 const AccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos,
17410 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
17411 {
17412 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
17413 return static_cast<Result>(
17414 d.vkBuildAccelerationStructuresKHR( static_cast<VkDevice>( m_device ),
17415 static_cast<VkDeferredOperationKHR>( deferredOperation ),
17416 infoCount,
17417 reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>( pInfos ),
17418 reinterpret_cast<const VkAccelerationStructureBuildRangeInfoKHR * const *>( ppBuildRangeInfos ) ) );
17419 }
17420
17421 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17422 // wrapper function for command vkBuildAccelerationStructuresKHR, see
17423 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBuildAccelerationStructuresKHR.html
17424 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
17425 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
17426 Device::buildAccelerationStructuresKHR( DeferredOperationKHR deferredOperation,
17427 ArrayProxy<const AccelerationStructureBuildGeometryInfoKHR> const & infos,
17428 ArrayProxy<const AccelerationStructureBuildRangeInfoKHR * const> const & pBuildRangeInfos,
17429 Dispatch const & d ) const
17430 {
17431 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
17432 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
17433 VULKAN_HPP_ASSERT( d.vkBuildAccelerationStructuresKHR && "Function <vkBuildAccelerationStructuresKHR> requires <VK_KHR_acceleration_structure>" );
17434 # endif
17435 # ifdef VULKAN_HPP_NO_EXCEPTIONS
17436 VULKAN_HPP_ASSERT( infos.size() == pBuildRangeInfos.size() );
17437 # else
17438 if ( infos.size() != pBuildRangeInfos.size() )
17439 {
17440 throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::Device::buildAccelerationStructuresKHR: infos.size() != pBuildRangeInfos.size()" );
17441 }
17442 # endif /*VULKAN_HPP_NO_EXCEPTIONS*/
17443
17444 Result result = static_cast<Result>(
17445 d.vkBuildAccelerationStructuresKHR( m_device,
17446 static_cast<VkDeferredOperationKHR>( deferredOperation ),
17447 infos.size(),
17448 reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>( infos.data() ),
17449 reinterpret_cast<const VkAccelerationStructureBuildRangeInfoKHR * const *>( pBuildRangeInfos.data() ) ) );
17450 detail::resultCheck( result,
17451 VULKAN_HPP_NAMESPACE_STRING "::Device::buildAccelerationStructuresKHR",
17452 { Result::eSuccess, Result::eOperationDeferredKHR, Result::eOperationNotDeferredKHR } );
17453
17454 return static_cast<Result>( result );
17455 }
17456 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17457
17458 // wrapper function for command vkCopyAccelerationStructureKHR, see
17459 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyAccelerationStructureKHR.html
17460 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
17461 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyAccelerationStructureKHR( DeferredOperationKHR deferredOperation,
17462 const CopyAccelerationStructureInfoKHR * pInfo,
17463 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
17464 {
17465 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
17466 return static_cast<Result>( d.vkCopyAccelerationStructureKHR( static_cast<VkDevice>( m_device ),
17467 static_cast<VkDeferredOperationKHR>( deferredOperation ),
17468 reinterpret_cast<const VkCopyAccelerationStructureInfoKHR *>( pInfo ) ) );
17469 }
17470
17471 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17472 // wrapper function for command vkCopyAccelerationStructureKHR, see
17473 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyAccelerationStructureKHR.html
17474 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
17475 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyAccelerationStructureKHR( DeferredOperationKHR deferredOperation,
17476 const CopyAccelerationStructureInfoKHR & info,
17477 Dispatch const & d ) const
17478 {
17479 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
17480 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
17481 VULKAN_HPP_ASSERT( d.vkCopyAccelerationStructureKHR && "Function <vkCopyAccelerationStructureKHR> requires <VK_KHR_acceleration_structure>" );
17482 # endif
17483
17484 Result result = static_cast<Result>( d.vkCopyAccelerationStructureKHR(
17485 m_device, static_cast<VkDeferredOperationKHR>( deferredOperation ), reinterpret_cast<const VkCopyAccelerationStructureInfoKHR *>( &info ) ) );
17486 detail::resultCheck( result,
17487 VULKAN_HPP_NAMESPACE_STRING "::Device::copyAccelerationStructureKHR",
17488 { Result::eSuccess, Result::eOperationDeferredKHR, Result::eOperationNotDeferredKHR } );
17489
17490 return static_cast<Result>( result );
17491 }
17492 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17493
17494 // wrapper function for command vkCopyAccelerationStructureToMemoryKHR, see
17495 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyAccelerationStructureToMemoryKHR.html
17496 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
17497 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyAccelerationStructureToMemoryKHR( DeferredOperationKHR deferredOperation,
17498 const CopyAccelerationStructureToMemoryInfoKHR * pInfo,
17499 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
17500 {
17501 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
17502 return static_cast<Result>( d.vkCopyAccelerationStructureToMemoryKHR( static_cast<VkDevice>( m_device ),
17503 static_cast<VkDeferredOperationKHR>( deferredOperation ),
17504 reinterpret_cast<const VkCopyAccelerationStructureToMemoryInfoKHR *>( pInfo ) ) );
17505 }
17506
17507 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17508 // wrapper function for command vkCopyAccelerationStructureToMemoryKHR, see
17509 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyAccelerationStructureToMemoryKHR.html
17510 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
17511 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyAccelerationStructureToMemoryKHR( DeferredOperationKHR deferredOperation,
17512 const CopyAccelerationStructureToMemoryInfoKHR & info,
17513 Dispatch const & d ) const
17514 {
17515 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
17516 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
17517 VULKAN_HPP_ASSERT( d.vkCopyAccelerationStructureToMemoryKHR &&
17518 "Function <vkCopyAccelerationStructureToMemoryKHR> requires <VK_KHR_acceleration_structure>" );
17519 # endif
17520
17521 Result result = static_cast<Result>( d.vkCopyAccelerationStructureToMemoryKHR(
17522 m_device, static_cast<VkDeferredOperationKHR>( deferredOperation ), reinterpret_cast<const VkCopyAccelerationStructureToMemoryInfoKHR *>( &info ) ) );
17523 detail::resultCheck( result,
17524 VULKAN_HPP_NAMESPACE_STRING "::Device::copyAccelerationStructureToMemoryKHR",
17525 { Result::eSuccess, Result::eOperationDeferredKHR, Result::eOperationNotDeferredKHR } );
17526
17527 return static_cast<Result>( result );
17528 }
17529 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17530
17531 // wrapper function for command vkCopyMemoryToAccelerationStructureKHR, see
17532 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToAccelerationStructureKHR.html
17533 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
17534 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyMemoryToAccelerationStructureKHR( DeferredOperationKHR deferredOperation,
17535 const CopyMemoryToAccelerationStructureInfoKHR * pInfo,
17536 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
17537 {
17538 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
17539 return static_cast<Result>( d.vkCopyMemoryToAccelerationStructureKHR( static_cast<VkDevice>( m_device ),
17540 static_cast<VkDeferredOperationKHR>( deferredOperation ),
17541 reinterpret_cast<const VkCopyMemoryToAccelerationStructureInfoKHR *>( pInfo ) ) );
17542 }
17543
17544 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17545 // wrapper function for command vkCopyMemoryToAccelerationStructureKHR, see
17546 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToAccelerationStructureKHR.html
17547 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
17548 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyMemoryToAccelerationStructureKHR( DeferredOperationKHR deferredOperation,
17549 const CopyMemoryToAccelerationStructureInfoKHR & info,
17550 Dispatch const & d ) const
17551 {
17552 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
17553 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
17554 VULKAN_HPP_ASSERT( d.vkCopyMemoryToAccelerationStructureKHR &&
17555 "Function <vkCopyMemoryToAccelerationStructureKHR> requires <VK_KHR_acceleration_structure>" );
17556 # endif
17557
17558 Result result = static_cast<Result>( d.vkCopyMemoryToAccelerationStructureKHR(
17559 m_device, static_cast<VkDeferredOperationKHR>( deferredOperation ), reinterpret_cast<const VkCopyMemoryToAccelerationStructureInfoKHR *>( &info ) ) );
17560 detail::resultCheck( result,
17561 VULKAN_HPP_NAMESPACE_STRING "::Device::copyMemoryToAccelerationStructureKHR",
17562 { Result::eSuccess, Result::eOperationDeferredKHR, Result::eOperationNotDeferredKHR } );
17563
17564 return static_cast<Result>( result );
17565 }
17566 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17567
17568 // wrapper function for command vkWriteAccelerationStructuresPropertiesKHR, see
17569 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteAccelerationStructuresPropertiesKHR.html
17570 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
17571 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::writeAccelerationStructuresPropertiesKHR( uint32_t accelerationStructureCount,
17572 const AccelerationStructureKHR * pAccelerationStructures,
17573 QueryType queryType,
17574 size_t dataSize,
17575 void * pData,
17576 size_t stride,
17577 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
17578 {
17579 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
17580 return static_cast<Result>( d.vkWriteAccelerationStructuresPropertiesKHR( static_cast<VkDevice>( m_device ),
17581 accelerationStructureCount,
17582 reinterpret_cast<const VkAccelerationStructureKHR *>( pAccelerationStructures ),
17583 static_cast<VkQueryType>( queryType ),
17584 dataSize,
17585 pData,
17586 stride ) );
17587 }
17588
17589 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17590 // wrapper function for command vkWriteAccelerationStructuresPropertiesKHR, see
17591 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteAccelerationStructuresPropertiesKHR.html
17592 template <typename DataType,
17593 typename DataTypeAllocator,
17594 typename Dispatch,
17595 typename std::enable_if<std::is_same<typename DataTypeAllocator::value_type, DataType>::value, int>::type,
17596 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
17597 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type
17598 Device::writeAccelerationStructuresPropertiesKHR(
17599 ArrayProxy<const AccelerationStructureKHR> const & accelerationStructures, QueryType queryType, size_t dataSize, size_t stride, Dispatch const & d ) const
17600 {
17601 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
17602 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
17603 VULKAN_HPP_ASSERT( d.vkWriteAccelerationStructuresPropertiesKHR &&
17604 "Function <vkWriteAccelerationStructuresPropertiesKHR> requires <VK_KHR_acceleration_structure>" );
17605 # endif
17606
17607 VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 );
17608 std::vector<DataType, DataTypeAllocator> data( dataSize / sizeof( DataType ) );
17609 Result result =
17610 static_cast<Result>( d.vkWriteAccelerationStructuresPropertiesKHR( m_device,
17611 accelerationStructures.size(),
17612 reinterpret_cast<const VkAccelerationStructureKHR *>( accelerationStructures.data() ),
17613 static_cast<VkQueryType>( queryType ),
17614 data.size() * sizeof( DataType ),
17615 reinterpret_cast<void *>( data.data() ),
17616 stride ) );
17617 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::writeAccelerationStructuresPropertiesKHR" );
17618
17619 return detail::createResultValueType( result, std::move( data ) );
17620 }
17621
17622 // wrapper function for command vkWriteAccelerationStructuresPropertiesKHR, see
17623 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteAccelerationStructuresPropertiesKHR.html
17624 template <typename DataType, typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
17625 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<DataType>::type Device::writeAccelerationStructuresPropertyKHR(
17626 ArrayProxy<const AccelerationStructureKHR> const & accelerationStructures, QueryType queryType, size_t stride, Dispatch const & d ) const
17627 {
17628 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
17629 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
17630 VULKAN_HPP_ASSERT( d.vkWriteAccelerationStructuresPropertiesKHR &&
17631 "Function <vkWriteAccelerationStructuresPropertiesKHR> requires <VK_KHR_acceleration_structure>" );
17632 # endif
17633
17634 DataType data;
17635 Result result =
17636 static_cast<Result>( d.vkWriteAccelerationStructuresPropertiesKHR( m_device,
17637 accelerationStructures.size(),
17638 reinterpret_cast<const VkAccelerationStructureKHR *>( accelerationStructures.data() ),
17639 static_cast<VkQueryType>( queryType ),
17640 sizeof( DataType ),
17641 reinterpret_cast<void *>( &data ),
17642 stride ) );
17643 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::writeAccelerationStructuresPropertyKHR" );
17644
17645 return detail::createResultValueType( result, std::move( data ) );
17646 }
17647 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17648
17649 // wrapper function for command vkCmdCopyAccelerationStructureKHR, see
17650 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyAccelerationStructureKHR.html
17651 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
17652 VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureKHR( const CopyAccelerationStructureInfoKHR * pInfo,
17653 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
17654 {
17655 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
17656 d.vkCmdCopyAccelerationStructureKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
17657 reinterpret_cast<const VkCopyAccelerationStructureInfoKHR *>( pInfo ) );
17658 }
17659
17660 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17661 // wrapper function for command vkCmdCopyAccelerationStructureKHR, see
17662 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyAccelerationStructureKHR.html
17663 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
17664 VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureKHR( const CopyAccelerationStructureInfoKHR & info,
17665 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
17666 {
17667 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
17668 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
17669 VULKAN_HPP_ASSERT( d.vkCmdCopyAccelerationStructureKHR && "Function <vkCmdCopyAccelerationStructureKHR> requires <VK_KHR_acceleration_structure>" );
17670 # endif
17671
17672 d.vkCmdCopyAccelerationStructureKHR( m_commandBuffer, reinterpret_cast<const VkCopyAccelerationStructureInfoKHR *>( &info ) );
17673 }
17674 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17675
17676 // wrapper function for command vkCmdCopyAccelerationStructureToMemoryKHR, see
17677 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyAccelerationStructureToMemoryKHR.html
17678 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
17679 VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureToMemoryKHR( const CopyAccelerationStructureToMemoryInfoKHR * pInfo,
17680 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
17681 {
17682 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
17683 d.vkCmdCopyAccelerationStructureToMemoryKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
17684 reinterpret_cast<const VkCopyAccelerationStructureToMemoryInfoKHR *>( pInfo ) );
17685 }
17686
17687 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17688 // wrapper function for command vkCmdCopyAccelerationStructureToMemoryKHR, see
17689 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyAccelerationStructureToMemoryKHR.html
17690 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
17691 VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureToMemoryKHR( const CopyAccelerationStructureToMemoryInfoKHR & info,
17692 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
17693 {
17694 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
17695 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
17696 VULKAN_HPP_ASSERT( d.vkCmdCopyAccelerationStructureToMemoryKHR &&
17697 "Function <vkCmdCopyAccelerationStructureToMemoryKHR> requires <VK_KHR_acceleration_structure>" );
17698 # endif
17699
17700 d.vkCmdCopyAccelerationStructureToMemoryKHR( m_commandBuffer, reinterpret_cast<const VkCopyAccelerationStructureToMemoryInfoKHR *>( &info ) );
17701 }
17702 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17703
17704 // wrapper function for command vkCmdCopyMemoryToAccelerationStructureKHR, see
17705 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToAccelerationStructureKHR.html
17706 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
17707 VULKAN_HPP_INLINE void CommandBuffer::copyMemoryToAccelerationStructureKHR( const CopyMemoryToAccelerationStructureInfoKHR * pInfo,
17708 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
17709 {
17710 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
17711 d.vkCmdCopyMemoryToAccelerationStructureKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
17712 reinterpret_cast<const VkCopyMemoryToAccelerationStructureInfoKHR *>( pInfo ) );
17713 }
17714
17715 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17716 // wrapper function for command vkCmdCopyMemoryToAccelerationStructureKHR, see
17717 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToAccelerationStructureKHR.html
17718 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
17719 VULKAN_HPP_INLINE void CommandBuffer::copyMemoryToAccelerationStructureKHR( const CopyMemoryToAccelerationStructureInfoKHR & info,
17720 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
17721 {
17722 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
17723 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
17724 VULKAN_HPP_ASSERT( d.vkCmdCopyMemoryToAccelerationStructureKHR &&
17725 "Function <vkCmdCopyMemoryToAccelerationStructureKHR> requires <VK_KHR_acceleration_structure>" );
17726 # endif
17727
17728 d.vkCmdCopyMemoryToAccelerationStructureKHR( m_commandBuffer, reinterpret_cast<const VkCopyMemoryToAccelerationStructureInfoKHR *>( &info ) );
17729 }
17730 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17731
17732 // wrapper function for command vkGetAccelerationStructureDeviceAddressKHR, see
17733 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureDeviceAddressKHR.html
17734 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
17735 VULKAN_HPP_INLINE DeviceAddress Device::getAccelerationStructureAddressKHR( const AccelerationStructureDeviceAddressInfoKHR * pInfo,
17736 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
17737 {
17738 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
17739 return static_cast<DeviceAddress>( d.vkGetAccelerationStructureDeviceAddressKHR(
17740 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkAccelerationStructureDeviceAddressInfoKHR *>( pInfo ) ) );
17741 }
17742
17743 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17744 // wrapper function for command vkGetAccelerationStructureDeviceAddressKHR, see
17745 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureDeviceAddressKHR.html
17746 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
17747 VULKAN_HPP_INLINE DeviceAddress Device::getAccelerationStructureAddressKHR( const AccelerationStructureDeviceAddressInfoKHR & info,
17748 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
17749 {
17750 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
17751 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
17752 VULKAN_HPP_ASSERT( d.vkGetAccelerationStructureDeviceAddressKHR &&
17753 "Function <vkGetAccelerationStructureDeviceAddressKHR> requires <VK_KHR_acceleration_structure>" );
17754 # endif
17755
17756 VkDeviceAddress result =
17757 d.vkGetAccelerationStructureDeviceAddressKHR( m_device, reinterpret_cast<const VkAccelerationStructureDeviceAddressInfoKHR *>( &info ) );
17758
17759 return static_cast<DeviceAddress>( result );
17760 }
17761 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17762
17763 // wrapper function for command vkCmdWriteAccelerationStructuresPropertiesKHR, see
17764 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteAccelerationStructuresPropertiesKHR.html
17765 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
17766 VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesKHR( uint32_t accelerationStructureCount,
17767 const AccelerationStructureKHR * pAccelerationStructures,
17768 QueryType queryType,
17769 QueryPool queryPool,
17770 uint32_t firstQuery,
17771 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
17772 {
17773 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
17774 d.vkCmdWriteAccelerationStructuresPropertiesKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
17775 accelerationStructureCount,
17776 reinterpret_cast<const VkAccelerationStructureKHR *>( pAccelerationStructures ),
17777 static_cast<VkQueryType>( queryType ),
17778 static_cast<VkQueryPool>( queryPool ),
17779 firstQuery );
17780 }
17781
17782 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17783 // wrapper function for command vkCmdWriteAccelerationStructuresPropertiesKHR, see
17784 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteAccelerationStructuresPropertiesKHR.html
17785 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
17786 VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesKHR( ArrayProxy<const AccelerationStructureKHR> const & accelerationStructures,
17787 QueryType queryType,
17788 QueryPool queryPool,
17789 uint32_t firstQuery,
17790 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
17791 {
17792 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
17793 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
17794 VULKAN_HPP_ASSERT( d.vkCmdWriteAccelerationStructuresPropertiesKHR &&
17795 "Function <vkCmdWriteAccelerationStructuresPropertiesKHR> requires <VK_KHR_acceleration_structure>" );
17796 # endif
17797
17798 d.vkCmdWriteAccelerationStructuresPropertiesKHR( m_commandBuffer,
17799 accelerationStructures.size(),
17800 reinterpret_cast<const VkAccelerationStructureKHR *>( accelerationStructures.data() ),
17801 static_cast<VkQueryType>( queryType ),
17802 static_cast<VkQueryPool>( queryPool ),
17803 firstQuery );
17804 }
17805 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17806
17807 // wrapper function for command vkGetDeviceAccelerationStructureCompatibilityKHR, see
17808 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceAccelerationStructureCompatibilityKHR.html
17809 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
17810 VULKAN_HPP_INLINE void Device::getAccelerationStructureCompatibilityKHR( const AccelerationStructureVersionInfoKHR * pVersionInfo,
17811 AccelerationStructureCompatibilityKHR * pCompatibility,
17812 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
17813 {
17814 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
17815 d.vkGetDeviceAccelerationStructureCompatibilityKHR( static_cast<VkDevice>( m_device ),
17816 reinterpret_cast<const VkAccelerationStructureVersionInfoKHR *>( pVersionInfo ),
17817 reinterpret_cast<VkAccelerationStructureCompatibilityKHR *>( pCompatibility ) );
17818 }
17819
17820 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17821 // wrapper function for command vkGetDeviceAccelerationStructureCompatibilityKHR, see
17822 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceAccelerationStructureCompatibilityKHR.html
17823 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
17824 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE AccelerationStructureCompatibilityKHR
17825 Device::getAccelerationStructureCompatibilityKHR( const AccelerationStructureVersionInfoKHR & versionInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
17826 {
17827 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
17828 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
17829 VULKAN_HPP_ASSERT( d.vkGetDeviceAccelerationStructureCompatibilityKHR &&
17830 "Function <vkGetDeviceAccelerationStructureCompatibilityKHR> requires <VK_KHR_acceleration_structure>" );
17831 # endif
17832
17833 AccelerationStructureCompatibilityKHR compatibility;
17834 d.vkGetDeviceAccelerationStructureCompatibilityKHR( m_device,
17835 reinterpret_cast<const VkAccelerationStructureVersionInfoKHR *>( &versionInfo ),
17836 reinterpret_cast<VkAccelerationStructureCompatibilityKHR *>( &compatibility ) );
17837
17838 return compatibility;
17839 }
17840 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17841
17842 // wrapper function for command vkGetAccelerationStructureBuildSizesKHR, see
17843 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureBuildSizesKHR.html
17844 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
17845 VULKAN_HPP_INLINE void Device::getAccelerationStructureBuildSizesKHR( AccelerationStructureBuildTypeKHR buildType,
17846 const AccelerationStructureBuildGeometryInfoKHR * pBuildInfo,
17847 const uint32_t * pMaxPrimitiveCounts,
17848 AccelerationStructureBuildSizesInfoKHR * pSizeInfo,
17849 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
17850 {
17851 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
17852 d.vkGetAccelerationStructureBuildSizesKHR( static_cast<VkDevice>( m_device ),
17853 static_cast<VkAccelerationStructureBuildTypeKHR>( buildType ),
17854 reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>( pBuildInfo ),
17855 pMaxPrimitiveCounts,
17856 reinterpret_cast<VkAccelerationStructureBuildSizesInfoKHR *>( pSizeInfo ) );
17857 }
17858
17859 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17860 // wrapper function for command vkGetAccelerationStructureBuildSizesKHR, see
17861 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureBuildSizesKHR.html
17862 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
17863 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE AccelerationStructureBuildSizesInfoKHR
17864 Device::getAccelerationStructureBuildSizesKHR( AccelerationStructureBuildTypeKHR buildType,
17865 const AccelerationStructureBuildGeometryInfoKHR & buildInfo,
17866 ArrayProxy<const uint32_t> const & maxPrimitiveCounts,
17867 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
17868 {
17869 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
17870 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
17871 VULKAN_HPP_ASSERT( d.vkGetAccelerationStructureBuildSizesKHR &&
17872 "Function <vkGetAccelerationStructureBuildSizesKHR> requires <VK_KHR_acceleration_structure>" );
17873 # endif
17874 # ifdef VULKAN_HPP_NO_EXCEPTIONS
17875 VULKAN_HPP_ASSERT( maxPrimitiveCounts.size() == buildInfo.geometryCount );
17876 # else
17877 if ( maxPrimitiveCounts.size() != buildInfo.geometryCount )
17878 {
17879 throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::Device::getAccelerationStructureBuildSizesKHR: maxPrimitiveCounts.size() != buildInfo.geometryCount" );
17880 }
17881 # endif /*VULKAN_HPP_NO_EXCEPTIONS*/
17882
17883 AccelerationStructureBuildSizesInfoKHR sizeInfo;
17884 d.vkGetAccelerationStructureBuildSizesKHR( m_device,
17885 static_cast<VkAccelerationStructureBuildTypeKHR>( buildType ),
17886 reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>( &buildInfo ),
17887 maxPrimitiveCounts.data(),
17888 reinterpret_cast<VkAccelerationStructureBuildSizesInfoKHR *>( &sizeInfo ) );
17889
17890 return sizeInfo;
17891 }
17892 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17893
17894 //=== VK_KHR_ray_tracing_pipeline ===
17895
17896 // wrapper function for command vkCmdTraceRaysKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdTraceRaysKHR.html
17897 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
17898 VULKAN_HPP_INLINE void CommandBuffer::traceRaysKHR( const StridedDeviceAddressRegionKHR * pRaygenShaderBindingTable,
17899 const StridedDeviceAddressRegionKHR * pMissShaderBindingTable,
17900 const StridedDeviceAddressRegionKHR * pHitShaderBindingTable,
17901 const StridedDeviceAddressRegionKHR * pCallableShaderBindingTable,
17902 uint32_t width,
17903 uint32_t height,
17904 uint32_t depth,
17905 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
17906 {
17907 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
17908 d.vkCmdTraceRaysKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
17909 reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( pRaygenShaderBindingTable ),
17910 reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( pMissShaderBindingTable ),
17911 reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( pHitShaderBindingTable ),
17912 reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( pCallableShaderBindingTable ),
17913 width,
17914 height,
17915 depth );
17916 }
17917
17918 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17919 // wrapper function for command vkCmdTraceRaysKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdTraceRaysKHR.html
17920 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
17921 VULKAN_HPP_INLINE void CommandBuffer::traceRaysKHR( const StridedDeviceAddressRegionKHR & raygenShaderBindingTable,
17922 const StridedDeviceAddressRegionKHR & missShaderBindingTable,
17923 const StridedDeviceAddressRegionKHR & hitShaderBindingTable,
17924 const StridedDeviceAddressRegionKHR & callableShaderBindingTable,
17925 uint32_t width,
17926 uint32_t height,
17927 uint32_t depth,
17928 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
17929 {
17930 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
17931 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
17932 VULKAN_HPP_ASSERT( d.vkCmdTraceRaysKHR && "Function <vkCmdTraceRaysKHR> requires <VK_KHR_ray_tracing_pipeline>" );
17933 # endif
17934
17935 d.vkCmdTraceRaysKHR( m_commandBuffer,
17936 reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &raygenShaderBindingTable ),
17937 reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &missShaderBindingTable ),
17938 reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &hitShaderBindingTable ),
17939 reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &callableShaderBindingTable ),
17940 width,
17941 height,
17942 depth );
17943 }
17944 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17945
17946 // wrapper function for command vkCreateRayTracingPipelinesKHR, see
17947 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesKHR.html
17948 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
17949 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createRayTracingPipelinesKHR( DeferredOperationKHR deferredOperation,
17950 PipelineCache pipelineCache,
17951 uint32_t createInfoCount,
17952 const RayTracingPipelineCreateInfoKHR * pCreateInfos,
17953 const AllocationCallbacks * pAllocator,
17954 Pipeline * pPipelines,
17955 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
17956 {
17957 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
17958 return static_cast<Result>( d.vkCreateRayTracingPipelinesKHR( static_cast<VkDevice>( m_device ),
17959 static_cast<VkDeferredOperationKHR>( deferredOperation ),
17960 static_cast<VkPipelineCache>( pipelineCache ),
17961 createInfoCount,
17962 reinterpret_cast<const VkRayTracingPipelineCreateInfoKHR *>( pCreateInfos ),
17963 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
17964 reinterpret_cast<VkPipeline *>( pPipelines ) ) );
17965 }
17966
17967 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17968 // wrapper function for command vkCreateRayTracingPipelinesKHR, see
17969 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesKHR.html
17970 template <typename PipelineAllocator,
17971 typename Dispatch,
17972 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, Pipeline>::value, int>::type,
17973 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
17974 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<Pipeline, PipelineAllocator>>
17975 Device::createRayTracingPipelinesKHR( DeferredOperationKHR deferredOperation,
17976 PipelineCache pipelineCache,
17977 ArrayProxy<const RayTracingPipelineCreateInfoKHR> const & createInfos,
17978 Optional<const AllocationCallbacks> allocator,
17979 Dispatch const & d ) const
17980 {
17981 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
17982 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
17983 VULKAN_HPP_ASSERT( d.vkCreateRayTracingPipelinesKHR && "Function <vkCreateRayTracingPipelinesKHR> requires <VK_KHR_ray_tracing_pipeline>" );
17984 # endif
17985
17986 std::vector<Pipeline, PipelineAllocator> pipelines( createInfos.size() );
17987 Result result = static_cast<Result>( d.vkCreateRayTracingPipelinesKHR( m_device,
17988 static_cast<VkDeferredOperationKHR>( deferredOperation ),
17989 static_cast<VkPipelineCache>( pipelineCache ),
17990 createInfos.size(),
17991 reinterpret_cast<const VkRayTracingPipelineCreateInfoKHR *>( createInfos.data() ),
17992 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
17993 reinterpret_cast<VkPipeline *>( pipelines.data() ) ) );
17994 detail::resultCheck( result,
17995 VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesKHR",
17996 { Result::eSuccess, Result::eOperationDeferredKHR, Result::eOperationNotDeferredKHR, Result::ePipelineCompileRequiredEXT } );
17997
17998 return ResultValue<std::vector<Pipeline, PipelineAllocator>>( result, std::move( pipelines ) );
17999 }
18000
18001 // wrapper function for command vkCreateRayTracingPipelinesKHR, see
18002 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesKHR.html
18003 template <typename PipelineAllocator,
18004 typename Dispatch,
18005 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, Pipeline>::value, int>::type,
18006 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
18007 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<Pipeline, PipelineAllocator>>
18008 Device::createRayTracingPipelinesKHR( DeferredOperationKHR deferredOperation,
18009 PipelineCache pipelineCache,
18010 ArrayProxy<const RayTracingPipelineCreateInfoKHR> const & createInfos,
18011 Optional<const AllocationCallbacks> allocator,
18012 PipelineAllocator & pipelineAllocator,
18013 Dispatch const & d ) const
18014 {
18015 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
18016 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
18017 VULKAN_HPP_ASSERT( d.vkCreateRayTracingPipelinesKHR && "Function <vkCreateRayTracingPipelinesKHR> requires <VK_KHR_ray_tracing_pipeline>" );
18018 # endif
18019
18020 std::vector<Pipeline, PipelineAllocator> pipelines( createInfos.size(), pipelineAllocator );
18021 Result result = static_cast<Result>( d.vkCreateRayTracingPipelinesKHR( m_device,
18022 static_cast<VkDeferredOperationKHR>( deferredOperation ),
18023 static_cast<VkPipelineCache>( pipelineCache ),
18024 createInfos.size(),
18025 reinterpret_cast<const VkRayTracingPipelineCreateInfoKHR *>( createInfos.data() ),
18026 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
18027 reinterpret_cast<VkPipeline *>( pipelines.data() ) ) );
18028 detail::resultCheck( result,
18029 VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesKHR",
18030 { Result::eSuccess, Result::eOperationDeferredKHR, Result::eOperationNotDeferredKHR, Result::ePipelineCompileRequiredEXT } );
18031
18032 return ResultValue<std::vector<Pipeline, PipelineAllocator>>( result, std::move( pipelines ) );
18033 }
18034
18035 // wrapper function for command vkCreateRayTracingPipelinesKHR, see
18036 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesKHR.html
18037 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
18038 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<Pipeline> Device::createRayTracingPipelineKHR( DeferredOperationKHR deferredOperation,
18039 PipelineCache pipelineCache,
18040 const RayTracingPipelineCreateInfoKHR & createInfo,
18041 Optional<const AllocationCallbacks> allocator,
18042 Dispatch const & d ) const
18043 {
18044 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
18045 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
18046 VULKAN_HPP_ASSERT( d.vkCreateRayTracingPipelinesKHR && "Function <vkCreateRayTracingPipelinesKHR> requires <VK_KHR_ray_tracing_pipeline>" );
18047 # endif
18048
18049 Pipeline pipeline;
18050 Result result = static_cast<Result>( d.vkCreateRayTracingPipelinesKHR( m_device,
18051 static_cast<VkDeferredOperationKHR>( deferredOperation ),
18052 static_cast<VkPipelineCache>( pipelineCache ),
18053 1,
18054 reinterpret_cast<const VkRayTracingPipelineCreateInfoKHR *>( &createInfo ),
18055 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
18056 reinterpret_cast<VkPipeline *>( &pipeline ) ) );
18057 detail::resultCheck( result,
18058 VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelineKHR",
18059 { Result::eSuccess, Result::eOperationDeferredKHR, Result::eOperationNotDeferredKHR, Result::ePipelineCompileRequiredEXT } );
18060
18061 return ResultValue<Pipeline>( result, std::move( pipeline ) );
18062 }
18063
18064 # ifndef VULKAN_HPP_NO_SMART_HANDLE
18065 // wrapper function for command vkCreateRayTracingPipelinesKHR, see
18066 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesKHR.html
18067 template <typename Dispatch,
18068 typename PipelineAllocator,
18069 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<Pipeline, Dispatch>>::value, int>::type,
18070 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
18071 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
18072 Device::createRayTracingPipelinesKHRUnique( DeferredOperationKHR deferredOperation,
18073 PipelineCache pipelineCache,
18074 ArrayProxy<const RayTracingPipelineCreateInfoKHR> const & createInfos,
18075 Optional<const AllocationCallbacks> allocator,
18076 Dispatch const & d ) const
18077 {
18078 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
18079 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
18080 VULKAN_HPP_ASSERT( d.vkCreateRayTracingPipelinesKHR && "Function <vkCreateRayTracingPipelinesKHR> requires <VK_KHR_ray_tracing_pipeline>" );
18081 # endif
18082
18083 std::vector<Pipeline> pipelines( createInfos.size() );
18084 Result result = static_cast<Result>( d.vkCreateRayTracingPipelinesKHR( m_device,
18085 static_cast<VkDeferredOperationKHR>( deferredOperation ),
18086 static_cast<VkPipelineCache>( pipelineCache ),
18087 createInfos.size(),
18088 reinterpret_cast<const VkRayTracingPipelineCreateInfoKHR *>( createInfos.data() ),
18089 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
18090 reinterpret_cast<VkPipeline *>( pipelines.data() ) ) );
18091 detail::resultCheck( result,
18092 VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesKHRUnique",
18093 { Result::eSuccess, Result::eOperationDeferredKHR, Result::eOperationNotDeferredKHR, Result::ePipelineCompileRequiredEXT } );
18094 std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator> uniquePipelines;
18095 uniquePipelines.reserve( createInfos.size() );
18096 detail::ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
18097 for ( auto const & pipeline : pipelines )
18098 {
18099 uniquePipelines.push_back( UniqueHandle<Pipeline, Dispatch>( pipeline, deleter ) );
18100 }
18101 return ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>( result, std::move( uniquePipelines ) );
18102 }
18103
18104 // wrapper function for command vkCreateRayTracingPipelinesKHR, see
18105 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesKHR.html
18106 template <typename Dispatch,
18107 typename PipelineAllocator,
18108 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<Pipeline, Dispatch>>::value, int>::type,
18109 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
18110 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
18111 Device::createRayTracingPipelinesKHRUnique( DeferredOperationKHR deferredOperation,
18112 PipelineCache pipelineCache,
18113 ArrayProxy<const RayTracingPipelineCreateInfoKHR> const & createInfos,
18114 Optional<const AllocationCallbacks> allocator,
18115 PipelineAllocator & pipelineAllocator,
18116 Dispatch const & d ) const
18117 {
18118 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
18119 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
18120 VULKAN_HPP_ASSERT( d.vkCreateRayTracingPipelinesKHR && "Function <vkCreateRayTracingPipelinesKHR> requires <VK_KHR_ray_tracing_pipeline>" );
18121 # endif
18122
18123 std::vector<Pipeline> pipelines( createInfos.size() );
18124 Result result = static_cast<Result>( d.vkCreateRayTracingPipelinesKHR( m_device,
18125 static_cast<VkDeferredOperationKHR>( deferredOperation ),
18126 static_cast<VkPipelineCache>( pipelineCache ),
18127 createInfos.size(),
18128 reinterpret_cast<const VkRayTracingPipelineCreateInfoKHR *>( createInfos.data() ),
18129 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
18130 reinterpret_cast<VkPipeline *>( pipelines.data() ) ) );
18131 detail::resultCheck( result,
18132 VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesKHRUnique",
18133 { Result::eSuccess, Result::eOperationDeferredKHR, Result::eOperationNotDeferredKHR, Result::ePipelineCompileRequiredEXT } );
18134 std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator> uniquePipelines( pipelineAllocator );
18135 uniquePipelines.reserve( createInfos.size() );
18136 detail::ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
18137 for ( auto const & pipeline : pipelines )
18138 {
18139 uniquePipelines.push_back( UniqueHandle<Pipeline, Dispatch>( pipeline, deleter ) );
18140 }
18141 return ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>( result, std::move( uniquePipelines ) );
18142 }
18143
18144 // wrapper function for command vkCreateRayTracingPipelinesKHR, see
18145 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesKHR.html
18146 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
18147 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<UniqueHandle<Pipeline, Dispatch>>
18148 Device::createRayTracingPipelineKHRUnique( DeferredOperationKHR deferredOperation,
18149 PipelineCache pipelineCache,
18150 const RayTracingPipelineCreateInfoKHR & createInfo,
18151 Optional<const AllocationCallbacks> allocator,
18152 Dispatch const & d ) const
18153 {
18154 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
18155 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
18156 VULKAN_HPP_ASSERT( d.vkCreateRayTracingPipelinesKHR && "Function <vkCreateRayTracingPipelinesKHR> requires <VK_KHR_ray_tracing_pipeline>" );
18157 # endif
18158
18159 Pipeline pipeline;
18160 Result result = static_cast<Result>( d.vkCreateRayTracingPipelinesKHR( m_device,
18161 static_cast<VkDeferredOperationKHR>( deferredOperation ),
18162 static_cast<VkPipelineCache>( pipelineCache ),
18163 1,
18164 reinterpret_cast<const VkRayTracingPipelineCreateInfoKHR *>( &createInfo ),
18165 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
18166 reinterpret_cast<VkPipeline *>( &pipeline ) ) );
18167 detail::resultCheck( result,
18168 VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelineKHRUnique",
18169 { Result::eSuccess, Result::eOperationDeferredKHR, Result::eOperationNotDeferredKHR, Result::ePipelineCompileRequiredEXT } );
18170
18171 return ResultValue<UniqueHandle<Pipeline, Dispatch>>(
18172 result, UniqueHandle<Pipeline, Dispatch>( pipeline, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
18173 }
18174 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
18175 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
18176
18177 // wrapper function for command vkGetRayTracingShaderGroupHandlesKHR, see
18178 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupHandlesKHR.html
18179 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
18180 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getRayTracingShaderGroupHandlesKHR(
18181 Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void * pData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
18182 {
18183 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
18184 return static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesKHR(
18185 static_cast<VkDevice>( m_device ), static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, dataSize, pData ) );
18186 }
18187
18188 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
18189 // wrapper function for command vkGetRayTracingShaderGroupHandlesKHR, see
18190 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupHandlesKHR.html
18191 template <typename DataType,
18192 typename DataTypeAllocator,
18193 typename Dispatch,
18194 typename std::enable_if<std::is_same<typename DataTypeAllocator::value_type, DataType>::value, int>::type,
18195 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
18196 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type
18197 Device::getRayTracingShaderGroupHandlesKHR( Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, Dispatch const & d ) const
18198 {
18199 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
18200 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
18201 VULKAN_HPP_ASSERT( d.vkGetRayTracingShaderGroupHandlesKHR &&
18202 "Function <vkGetRayTracingShaderGroupHandlesKHR> requires <VK_KHR_ray_tracing_pipeline> or <VK_NV_ray_tracing>" );
18203 # endif
18204
18205 VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 );
18206 std::vector<DataType, DataTypeAllocator> data( dataSize / sizeof( DataType ) );
18207 Result result = static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesKHR(
18208 m_device, static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, data.size() * sizeof( DataType ), reinterpret_cast<void *>( data.data() ) ) );
18209 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandlesKHR" );
18210
18211 return detail::createResultValueType( result, std::move( data ) );
18212 }
18213
18214 // wrapper function for command vkGetRayTracingShaderGroupHandlesKHR, see
18215 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupHandlesKHR.html
18216 template <typename DataType, typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
18217 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<DataType>::type
18218 Device::getRayTracingShaderGroupHandleKHR( Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const & d ) const
18219 {
18220 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
18221 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
18222 VULKAN_HPP_ASSERT( d.vkGetRayTracingShaderGroupHandlesKHR &&
18223 "Function <vkGetRayTracingShaderGroupHandlesKHR> requires <VK_KHR_ray_tracing_pipeline> or <VK_NV_ray_tracing>" );
18224 # endif
18225
18226 DataType data;
18227 Result result = static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesKHR(
18228 m_device, static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, sizeof( DataType ), reinterpret_cast<void *>( &data ) ) );
18229 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandleKHR" );
18230
18231 return detail::createResultValueType( result, std::move( data ) );
18232 }
18233 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
18234
18235 // wrapper function for command vkGetRayTracingCaptureReplayShaderGroupHandlesKHR, see
18236 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingCaptureReplayShaderGroupHandlesKHR.html
18237 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
18238 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getRayTracingCaptureReplayShaderGroupHandlesKHR(
18239 Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void * pData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
18240 {
18241 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
18242 return static_cast<Result>( d.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(
18243 static_cast<VkDevice>( m_device ), static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, dataSize, pData ) );
18244 }
18245
18246 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
18247 // wrapper function for command vkGetRayTracingCaptureReplayShaderGroupHandlesKHR, see
18248 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingCaptureReplayShaderGroupHandlesKHR.html
18249 template <typename DataType,
18250 typename DataTypeAllocator,
18251 typename Dispatch,
18252 typename std::enable_if<std::is_same<typename DataTypeAllocator::value_type, DataType>::value, int>::type,
18253 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
18254 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type
18255 Device::getRayTracingCaptureReplayShaderGroupHandlesKHR(
18256 Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, Dispatch const & d ) const
18257 {
18258 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
18259 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
18260 VULKAN_HPP_ASSERT( d.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR &&
18261 "Function <vkGetRayTracingCaptureReplayShaderGroupHandlesKHR> requires <VK_KHR_ray_tracing_pipeline>" );
18262 # endif
18263
18264 VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 );
18265 std::vector<DataType, DataTypeAllocator> data( dataSize / sizeof( DataType ) );
18266 Result result = static_cast<Result>( d.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(
18267 m_device, static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, data.size() * sizeof( DataType ), reinterpret_cast<void *>( data.data() ) ) );
18268 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingCaptureReplayShaderGroupHandlesKHR" );
18269
18270 return detail::createResultValueType( result, std::move( data ) );
18271 }
18272
18273 // wrapper function for command vkGetRayTracingCaptureReplayShaderGroupHandlesKHR, see
18274 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingCaptureReplayShaderGroupHandlesKHR.html
18275 template <typename DataType, typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
18276 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<DataType>::type
18277 Device::getRayTracingCaptureReplayShaderGroupHandleKHR( Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const & d ) const
18278 {
18279 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
18280 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
18281 VULKAN_HPP_ASSERT( d.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR &&
18282 "Function <vkGetRayTracingCaptureReplayShaderGroupHandlesKHR> requires <VK_KHR_ray_tracing_pipeline>" );
18283 # endif
18284
18285 DataType data;
18286 Result result = static_cast<Result>( d.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(
18287 m_device, static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, sizeof( DataType ), reinterpret_cast<void *>( &data ) ) );
18288 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingCaptureReplayShaderGroupHandleKHR" );
18289
18290 return detail::createResultValueType( result, std::move( data ) );
18291 }
18292 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
18293
18294 // wrapper function for command vkCmdTraceRaysIndirectKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdTraceRaysIndirectKHR.html
18295 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
18296 VULKAN_HPP_INLINE void CommandBuffer::traceRaysIndirectKHR( const StridedDeviceAddressRegionKHR * pRaygenShaderBindingTable,
18297 const StridedDeviceAddressRegionKHR * pMissShaderBindingTable,
18298 const StridedDeviceAddressRegionKHR * pHitShaderBindingTable,
18299 const StridedDeviceAddressRegionKHR * pCallableShaderBindingTable,
18300 DeviceAddress indirectDeviceAddress,
18301 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
18302 {
18303 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
18304 d.vkCmdTraceRaysIndirectKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
18305 reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( pRaygenShaderBindingTable ),
18306 reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( pMissShaderBindingTable ),
18307 reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( pHitShaderBindingTable ),
18308 reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( pCallableShaderBindingTable ),
18309 static_cast<VkDeviceAddress>( indirectDeviceAddress ) );
18310 }
18311
18312 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
18313 // wrapper function for command vkCmdTraceRaysIndirectKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdTraceRaysIndirectKHR.html
18314 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
18315 VULKAN_HPP_INLINE void CommandBuffer::traceRaysIndirectKHR( const StridedDeviceAddressRegionKHR & raygenShaderBindingTable,
18316 const StridedDeviceAddressRegionKHR & missShaderBindingTable,
18317 const StridedDeviceAddressRegionKHR & hitShaderBindingTable,
18318 const StridedDeviceAddressRegionKHR & callableShaderBindingTable,
18319 DeviceAddress indirectDeviceAddress,
18320 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
18321 {
18322 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
18323 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
18324 VULKAN_HPP_ASSERT( d.vkCmdTraceRaysIndirectKHR && "Function <vkCmdTraceRaysIndirectKHR> requires <VK_KHR_ray_tracing_pipeline>" );
18325 # endif
18326
18327 d.vkCmdTraceRaysIndirectKHR( m_commandBuffer,
18328 reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &raygenShaderBindingTable ),
18329 reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &missShaderBindingTable ),
18330 reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &hitShaderBindingTable ),
18331 reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &callableShaderBindingTable ),
18332 static_cast<VkDeviceAddress>( indirectDeviceAddress ) );
18333 }
18334 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
18335
18336 // wrapper function for command vkGetRayTracingShaderGroupStackSizeKHR, see
18337 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupStackSizeKHR.html
18338 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
18339 VULKAN_HPP_INLINE DeviceSize Device::getRayTracingShaderGroupStackSizeKHR( Pipeline pipeline,
18340 uint32_t group,
18341 ShaderGroupShaderKHR groupShader,
18342 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
18343 {
18344 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
18345 return static_cast<DeviceSize>( d.vkGetRayTracingShaderGroupStackSizeKHR(
18346 static_cast<VkDevice>( m_device ), static_cast<VkPipeline>( pipeline ), group, static_cast<VkShaderGroupShaderKHR>( groupShader ) ) );
18347 }
18348
18349 // wrapper function for command vkCmdSetRayTracingPipelineStackSizeKHR, see
18350 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRayTracingPipelineStackSizeKHR.html
18351 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
18352 VULKAN_HPP_INLINE void CommandBuffer::setRayTracingPipelineStackSizeKHR( uint32_t pipelineStackSize, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
18353 {
18354 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
18355 d.vkCmdSetRayTracingPipelineStackSizeKHR( static_cast<VkCommandBuffer>( m_commandBuffer ), pipelineStackSize );
18356 }
18357
18358 //=== VK_KHR_sampler_ycbcr_conversion ===
18359
18360 // wrapper function for command vkCreateSamplerYcbcrConversionKHR, see
18361 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSamplerYcbcrConversionKHR.html
18362 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
18363 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createSamplerYcbcrConversionKHR( const SamplerYcbcrConversionCreateInfo * pCreateInfo,
18364 const AllocationCallbacks * pAllocator,
18365 SamplerYcbcrConversion * pYcbcrConversion,
18366 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
18367 {
18368 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
18369 return static_cast<Result>( d.vkCreateSamplerYcbcrConversionKHR( static_cast<VkDevice>( m_device ),
18370 reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo *>( pCreateInfo ),
18371 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
18372 reinterpret_cast<VkSamplerYcbcrConversion *>( pYcbcrConversion ) ) );
18373 }
18374
18375 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
18376 // wrapper function for command vkCreateSamplerYcbcrConversionKHR, see
18377 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSamplerYcbcrConversionKHR.html
18378 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
18379 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<SamplerYcbcrConversion>::type Device::createSamplerYcbcrConversionKHR(
18380 const SamplerYcbcrConversionCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
18381 {
18382 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
18383 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
18384 VULKAN_HPP_ASSERT( d.vkCreateSamplerYcbcrConversionKHR &&
18385 "Function <vkCreateSamplerYcbcrConversionKHR> requires <VK_KHR_sampler_ycbcr_conversion> or <VK_VERSION_1_1>" );
18386 # endif
18387
18388 SamplerYcbcrConversion ycbcrConversion;
18389 Result result = static_cast<Result>( d.vkCreateSamplerYcbcrConversionKHR( m_device,
18390 reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo *>( &createInfo ),
18391 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
18392 reinterpret_cast<VkSamplerYcbcrConversion *>( &ycbcrConversion ) ) );
18393 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSamplerYcbcrConversionKHR" );
18394
18395 return detail::createResultValueType( result, std::move( ycbcrConversion ) );
18396 }
18397
18398 # ifndef VULKAN_HPP_NO_SMART_HANDLE
18399 // wrapper function for command vkCreateSamplerYcbcrConversionKHR, see
18400 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSamplerYcbcrConversionKHR.html
18401 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
18402 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SamplerYcbcrConversion, Dispatch>>::type
18403 Device::createSamplerYcbcrConversionKHRUnique( const SamplerYcbcrConversionCreateInfo & createInfo,
18404 Optional<const AllocationCallbacks> allocator,
18405 Dispatch const & d ) const
18406 {
18407 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
18408 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
18409 VULKAN_HPP_ASSERT( d.vkCreateSamplerYcbcrConversionKHR &&
18410 "Function <vkCreateSamplerYcbcrConversionKHR> requires <VK_KHR_sampler_ycbcr_conversion> or <VK_VERSION_1_1>" );
18411 # endif
18412
18413 SamplerYcbcrConversion ycbcrConversion;
18414 Result result = static_cast<Result>( d.vkCreateSamplerYcbcrConversionKHR( m_device,
18415 reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo *>( &createInfo ),
18416 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
18417 reinterpret_cast<VkSamplerYcbcrConversion *>( &ycbcrConversion ) ) );
18418 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSamplerYcbcrConversionKHRUnique" );
18419
18420 return detail::createResultValueType(
18421 result, UniqueHandle<SamplerYcbcrConversion, Dispatch>( ycbcrConversion, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
18422 }
18423 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
18424 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
18425
18426 // wrapper function for command vkDestroySamplerYcbcrConversionKHR, see
18427 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySamplerYcbcrConversionKHR.html
18428 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
18429 VULKAN_HPP_INLINE void Device::destroySamplerYcbcrConversionKHR( SamplerYcbcrConversion ycbcrConversion,
18430 const AllocationCallbacks * pAllocator,
18431 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
18432 {
18433 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
18434 d.vkDestroySamplerYcbcrConversionKHR( static_cast<VkDevice>( m_device ),
18435 static_cast<VkSamplerYcbcrConversion>( ycbcrConversion ),
18436 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
18437 }
18438
18439 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
18440 // wrapper function for command vkDestroySamplerYcbcrConversionKHR, see
18441 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySamplerYcbcrConversionKHR.html
18442 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
18443 VULKAN_HPP_INLINE void Device::destroySamplerYcbcrConversionKHR( SamplerYcbcrConversion ycbcrConversion,
18444 Optional<const AllocationCallbacks> allocator,
18445 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
18446 {
18447 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
18448 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
18449 VULKAN_HPP_ASSERT( d.vkDestroySamplerYcbcrConversionKHR &&
18450 "Function <vkDestroySamplerYcbcrConversionKHR> requires <VK_KHR_sampler_ycbcr_conversion> or <VK_VERSION_1_1>" );
18451 # endif
18452
18453 d.vkDestroySamplerYcbcrConversionKHR(
18454 m_device, static_cast<VkSamplerYcbcrConversion>( ycbcrConversion ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
18455 }
18456 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
18457
18458 //=== VK_KHR_bind_memory2 ===
18459
18460 // wrapper function for command vkBindBufferMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindBufferMemory2KHR.html
18461 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
18462 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::bindBufferMemory2KHR( uint32_t bindInfoCount,
18463 const BindBufferMemoryInfo * pBindInfos,
18464 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
18465 {
18466 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
18467 return static_cast<Result>(
18468 d.vkBindBufferMemory2KHR( static_cast<VkDevice>( m_device ), bindInfoCount, reinterpret_cast<const VkBindBufferMemoryInfo *>( pBindInfos ) ) );
18469 }
18470
18471 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
18472 // wrapper function for command vkBindBufferMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindBufferMemory2KHR.html
18473 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
18474 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
18475 Device::bindBufferMemory2KHR( ArrayProxy<const BindBufferMemoryInfo> const & bindInfos, Dispatch const & d ) const
18476 {
18477 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
18478 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
18479 VULKAN_HPP_ASSERT( d.vkBindBufferMemory2KHR && "Function <vkBindBufferMemory2KHR> requires <VK_KHR_bind_memory2> or <VK_VERSION_1_1>" );
18480 # endif
18481
18482 Result result =
18483 static_cast<Result>( d.vkBindBufferMemory2KHR( m_device, bindInfos.size(), reinterpret_cast<const VkBindBufferMemoryInfo *>( bindInfos.data() ) ) );
18484 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindBufferMemory2KHR" );
18485
18486 return detail::createResultValueType( result );
18487 }
18488 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
18489
18490 // wrapper function for command vkBindImageMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindImageMemory2KHR.html
18491 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
18492 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::bindImageMemory2KHR( uint32_t bindInfoCount,
18493 const BindImageMemoryInfo * pBindInfos,
18494 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
18495 {
18496 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
18497 return static_cast<Result>(
18498 d.vkBindImageMemory2KHR( static_cast<VkDevice>( m_device ), bindInfoCount, reinterpret_cast<const VkBindImageMemoryInfo *>( pBindInfos ) ) );
18499 }
18500
18501 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
18502 // wrapper function for command vkBindImageMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindImageMemory2KHR.html
18503 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
18504 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
18505 Device::bindImageMemory2KHR( ArrayProxy<const BindImageMemoryInfo> const & bindInfos, Dispatch const & d ) const
18506 {
18507 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
18508 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
18509 VULKAN_HPP_ASSERT( d.vkBindImageMemory2KHR && "Function <vkBindImageMemory2KHR> requires <VK_KHR_bind_memory2> or <VK_VERSION_1_1>" );
18510 # endif
18511
18512 Result result =
18513 static_cast<Result>( d.vkBindImageMemory2KHR( m_device, bindInfos.size(), reinterpret_cast<const VkBindImageMemoryInfo *>( bindInfos.data() ) ) );
18514 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindImageMemory2KHR" );
18515
18516 return detail::createResultValueType( result );
18517 }
18518 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
18519
18520 //=== VK_EXT_image_drm_format_modifier ===
18521
18522 // wrapper function for command vkGetImageDrmFormatModifierPropertiesEXT, see
18523 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageDrmFormatModifierPropertiesEXT.html
18524 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
18525 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getImageDrmFormatModifierPropertiesEXT( Image image,
18526 ImageDrmFormatModifierPropertiesEXT * pProperties,
18527 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
18528 {
18529 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
18530 return static_cast<Result>( d.vkGetImageDrmFormatModifierPropertiesEXT(
18531 static_cast<VkDevice>( m_device ), static_cast<VkImage>( image ), reinterpret_cast<VkImageDrmFormatModifierPropertiesEXT *>( pProperties ) ) );
18532 }
18533
18534 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
18535 // wrapper function for command vkGetImageDrmFormatModifierPropertiesEXT, see
18536 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageDrmFormatModifierPropertiesEXT.html
18537 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
18538 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<ImageDrmFormatModifierPropertiesEXT>::type
18539 Device::getImageDrmFormatModifierPropertiesEXT( Image image, Dispatch const & d ) const
18540 {
18541 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
18542 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
18543 VULKAN_HPP_ASSERT( d.vkGetImageDrmFormatModifierPropertiesEXT &&
18544 "Function <vkGetImageDrmFormatModifierPropertiesEXT> requires <VK_EXT_image_drm_format_modifier>" );
18545 # endif
18546
18547 ImageDrmFormatModifierPropertiesEXT properties;
18548 Result result = static_cast<Result>( d.vkGetImageDrmFormatModifierPropertiesEXT(
18549 m_device, static_cast<VkImage>( image ), reinterpret_cast<VkImageDrmFormatModifierPropertiesEXT *>( &properties ) ) );
18550 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getImageDrmFormatModifierPropertiesEXT" );
18551
18552 return detail::createResultValueType( result, std::move( properties ) );
18553 }
18554 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
18555
18556 //=== VK_EXT_validation_cache ===
18557
18558 // wrapper function for command vkCreateValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateValidationCacheEXT.html
18559 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
18560 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createValidationCacheEXT( const ValidationCacheCreateInfoEXT * pCreateInfo,
18561 const AllocationCallbacks * pAllocator,
18562 ValidationCacheEXT * pValidationCache,
18563 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
18564 {
18565 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
18566 return static_cast<Result>( d.vkCreateValidationCacheEXT( static_cast<VkDevice>( m_device ),
18567 reinterpret_cast<const VkValidationCacheCreateInfoEXT *>( pCreateInfo ),
18568 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
18569 reinterpret_cast<VkValidationCacheEXT *>( pValidationCache ) ) );
18570 }
18571
18572 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
18573 // wrapper function for command vkCreateValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateValidationCacheEXT.html
18574 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
18575 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<ValidationCacheEXT>::type
18576 Device::createValidationCacheEXT( const ValidationCacheCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
18577 {
18578 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
18579 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
18580 VULKAN_HPP_ASSERT( d.vkCreateValidationCacheEXT && "Function <vkCreateValidationCacheEXT> requires <VK_EXT_validation_cache>" );
18581 # endif
18582
18583 ValidationCacheEXT validationCache;
18584 Result result = static_cast<Result>( d.vkCreateValidationCacheEXT( m_device,
18585 reinterpret_cast<const VkValidationCacheCreateInfoEXT *>( &createInfo ),
18586 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
18587 reinterpret_cast<VkValidationCacheEXT *>( &validationCache ) ) );
18588 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createValidationCacheEXT" );
18589
18590 return detail::createResultValueType( result, std::move( validationCache ) );
18591 }
18592
18593 # ifndef VULKAN_HPP_NO_SMART_HANDLE
18594 // wrapper function for command vkCreateValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateValidationCacheEXT.html
18595 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
18596 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<ValidationCacheEXT, Dispatch>>::type Device::createValidationCacheEXTUnique(
18597 const ValidationCacheCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
18598 {
18599 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
18600 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
18601 VULKAN_HPP_ASSERT( d.vkCreateValidationCacheEXT && "Function <vkCreateValidationCacheEXT> requires <VK_EXT_validation_cache>" );
18602 # endif
18603
18604 ValidationCacheEXT validationCache;
18605 Result result = static_cast<Result>( d.vkCreateValidationCacheEXT( m_device,
18606 reinterpret_cast<const VkValidationCacheCreateInfoEXT *>( &createInfo ),
18607 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
18608 reinterpret_cast<VkValidationCacheEXT *>( &validationCache ) ) );
18609 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createValidationCacheEXTUnique" );
18610
18611 return detail::createResultValueType(
18612 result, UniqueHandle<ValidationCacheEXT, Dispatch>( validationCache, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
18613 }
18614 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
18615 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
18616
18617 // wrapper function for command vkDestroyValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyValidationCacheEXT.html
18618 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
18619 VULKAN_HPP_INLINE void Device::destroyValidationCacheEXT( ValidationCacheEXT validationCache,
18620 const AllocationCallbacks * pAllocator,
18621 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
18622 {
18623 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
18624 d.vkDestroyValidationCacheEXT(
18625 static_cast<VkDevice>( m_device ), static_cast<VkValidationCacheEXT>( validationCache ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
18626 }
18627
18628 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
18629 // wrapper function for command vkDestroyValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyValidationCacheEXT.html
18630 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
18631 VULKAN_HPP_INLINE void Device::destroyValidationCacheEXT( ValidationCacheEXT validationCache,
18632 Optional<const AllocationCallbacks> allocator,
18633 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
18634 {
18635 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
18636 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
18637 VULKAN_HPP_ASSERT( d.vkDestroyValidationCacheEXT && "Function <vkDestroyValidationCacheEXT> requires <VK_EXT_validation_cache>" );
18638 # endif
18639
18640 d.vkDestroyValidationCacheEXT(
18641 m_device, static_cast<VkValidationCacheEXT>( validationCache ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
18642 }
18643 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
18644
18645 // wrapper function for command vkDestroyValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyValidationCacheEXT.html
18646 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
18647 VULKAN_HPP_INLINE void
18648 Device::destroy( ValidationCacheEXT validationCache, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
18649 {
18650 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
18651 d.vkDestroyValidationCacheEXT(
18652 static_cast<VkDevice>( m_device ), static_cast<VkValidationCacheEXT>( validationCache ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
18653 }
18654
18655 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
18656 // wrapper function for command vkDestroyValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyValidationCacheEXT.html
18657 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
18658 VULKAN_HPP_INLINE void
18659 Device::destroy( ValidationCacheEXT validationCache, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
18660 {
18661 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
18662 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
18663 VULKAN_HPP_ASSERT( d.vkDestroyValidationCacheEXT && "Function <vkDestroyValidationCacheEXT> requires <VK_EXT_validation_cache>" );
18664 # endif
18665
18666 d.vkDestroyValidationCacheEXT(
18667 m_device, static_cast<VkValidationCacheEXT>( validationCache ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
18668 }
18669 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
18670
18671 // wrapper function for command vkMergeValidationCachesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMergeValidationCachesEXT.html
18672 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
18673 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::mergeValidationCachesEXT( ValidationCacheEXT dstCache,
18674 uint32_t srcCacheCount,
18675 const ValidationCacheEXT * pSrcCaches,
18676 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
18677 {
18678 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
18679 return static_cast<Result>( d.vkMergeValidationCachesEXT( static_cast<VkDevice>( m_device ),
18680 static_cast<VkValidationCacheEXT>( dstCache ),
18681 srcCacheCount,
18682 reinterpret_cast<const VkValidationCacheEXT *>( pSrcCaches ) ) );
18683 }
18684
18685 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
18686 // wrapper function for command vkMergeValidationCachesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMergeValidationCachesEXT.html
18687 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
18688 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
18689 Device::mergeValidationCachesEXT( ValidationCacheEXT dstCache, ArrayProxy<const ValidationCacheEXT> const & srcCaches, Dispatch const & d ) const
18690 {
18691 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
18692 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
18693 VULKAN_HPP_ASSERT( d.vkMergeValidationCachesEXT && "Function <vkMergeValidationCachesEXT> requires <VK_EXT_validation_cache>" );
18694 # endif
18695
18696 Result result = static_cast<Result>( d.vkMergeValidationCachesEXT(
18697 m_device, static_cast<VkValidationCacheEXT>( dstCache ), srcCaches.size(), reinterpret_cast<const VkValidationCacheEXT *>( srcCaches.data() ) ) );
18698 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::mergeValidationCachesEXT" );
18699
18700 return detail::createResultValueType( result );
18701 }
18702 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
18703
18704 // wrapper function for command vkGetValidationCacheDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetValidationCacheDataEXT.html
18705 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
18706 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
18707 Device::getValidationCacheDataEXT( ValidationCacheEXT validationCache, size_t * pDataSize, void * pData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
18708 {
18709 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
18710 return static_cast<Result>(
18711 d.vkGetValidationCacheDataEXT( static_cast<VkDevice>( m_device ), static_cast<VkValidationCacheEXT>( validationCache ), pDataSize, pData ) );
18712 }
18713
18714 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
18715 // wrapper function for command vkGetValidationCacheDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetValidationCacheDataEXT.html
18716 template <typename Uint8_tAllocator,
18717 typename Dispatch,
18718 typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type,
18719 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
18720 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
18721 Device::getValidationCacheDataEXT( ValidationCacheEXT validationCache, Dispatch const & d ) const
18722 {
18723 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
18724 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
18725 VULKAN_HPP_ASSERT( d.vkGetValidationCacheDataEXT && "Function <vkGetValidationCacheDataEXT> requires <VK_EXT_validation_cache>" );
18726 # endif
18727
18728 std::vector<uint8_t, Uint8_tAllocator> data;
18729 size_t dataSize;
18730 Result result;
18731 do
18732 {
18733 result = static_cast<Result>( d.vkGetValidationCacheDataEXT( m_device, static_cast<VkValidationCacheEXT>( validationCache ), &dataSize, nullptr ) );
18734 if ( ( result == Result::eSuccess ) && dataSize )
18735 {
18736 data.resize( dataSize );
18737 result = static_cast<Result>(
18738 d.vkGetValidationCacheDataEXT( m_device, static_cast<VkValidationCacheEXT>( validationCache ), &dataSize, reinterpret_cast<void *>( data.data() ) ) );
18739 }
18740 } while ( result == Result::eIncomplete );
18741 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getValidationCacheDataEXT" );
18742 VULKAN_HPP_ASSERT( dataSize <= data.size() );
18743 if ( dataSize < data.size() )
18744 {
18745 data.resize( dataSize );
18746 }
18747 return detail::createResultValueType( result, std::move( data ) );
18748 }
18749
18750 // wrapper function for command vkGetValidationCacheDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetValidationCacheDataEXT.html
18751 template <typename Uint8_tAllocator,
18752 typename Dispatch,
18753 typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type,
18754 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
18755 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
18756 Device::getValidationCacheDataEXT( ValidationCacheEXT validationCache, Uint8_tAllocator & uint8_tAllocator, Dispatch const & d ) const
18757 {
18758 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
18759 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
18760 VULKAN_HPP_ASSERT( d.vkGetValidationCacheDataEXT && "Function <vkGetValidationCacheDataEXT> requires <VK_EXT_validation_cache>" );
18761 # endif
18762
18763 std::vector<uint8_t, Uint8_tAllocator> data( uint8_tAllocator );
18764 size_t dataSize;
18765 Result result;
18766 do
18767 {
18768 result = static_cast<Result>( d.vkGetValidationCacheDataEXT( m_device, static_cast<VkValidationCacheEXT>( validationCache ), &dataSize, nullptr ) );
18769 if ( ( result == Result::eSuccess ) && dataSize )
18770 {
18771 data.resize( dataSize );
18772 result = static_cast<Result>(
18773 d.vkGetValidationCacheDataEXT( m_device, static_cast<VkValidationCacheEXT>( validationCache ), &dataSize, reinterpret_cast<void *>( data.data() ) ) );
18774 }
18775 } while ( result == Result::eIncomplete );
18776 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getValidationCacheDataEXT" );
18777 VULKAN_HPP_ASSERT( dataSize <= data.size() );
18778 if ( dataSize < data.size() )
18779 {
18780 data.resize( dataSize );
18781 }
18782 return detail::createResultValueType( result, std::move( data ) );
18783 }
18784 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
18785
18786 //=== VK_NV_shading_rate_image ===
18787
18788 // wrapper function for command vkCmdBindShadingRateImageNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindShadingRateImageNV.html
18789 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
18790 VULKAN_HPP_INLINE void CommandBuffer::bindShadingRateImageNV( ImageView imageView, ImageLayout imageLayout, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
18791 {
18792 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
18793 d.vkCmdBindShadingRateImageNV(
18794 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkImageView>( imageView ), static_cast<VkImageLayout>( imageLayout ) );
18795 }
18796
18797 // wrapper function for command vkCmdSetViewportShadingRatePaletteNV, see
18798 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportShadingRatePaletteNV.html
18799 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
18800 VULKAN_HPP_INLINE void CommandBuffer::setViewportShadingRatePaletteNV( uint32_t firstViewport,
18801 uint32_t viewportCount,
18802 const ShadingRatePaletteNV * pShadingRatePalettes,
18803 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
18804 {
18805 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
18806 d.vkCmdSetViewportShadingRatePaletteNV(
18807 static_cast<VkCommandBuffer>( m_commandBuffer ), firstViewport, viewportCount, reinterpret_cast<const VkShadingRatePaletteNV *>( pShadingRatePalettes ) );
18808 }
18809
18810 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
18811 // wrapper function for command vkCmdSetViewportShadingRatePaletteNV, see
18812 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportShadingRatePaletteNV.html
18813 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
18814 VULKAN_HPP_INLINE void CommandBuffer::setViewportShadingRatePaletteNV( uint32_t firstViewport,
18815 ArrayProxy<const ShadingRatePaletteNV> const & shadingRatePalettes,
18816 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
18817 {
18818 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
18819 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
18820 VULKAN_HPP_ASSERT( d.vkCmdSetViewportShadingRatePaletteNV && "Function <vkCmdSetViewportShadingRatePaletteNV> requires <VK_NV_shading_rate_image>" );
18821 # endif
18822
18823 d.vkCmdSetViewportShadingRatePaletteNV(
18824 m_commandBuffer, firstViewport, shadingRatePalettes.size(), reinterpret_cast<const VkShadingRatePaletteNV *>( shadingRatePalettes.data() ) );
18825 }
18826 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
18827
18828 // wrapper function for command vkCmdSetCoarseSampleOrderNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoarseSampleOrderNV.html
18829 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
18830 VULKAN_HPP_INLINE void CommandBuffer::setCoarseSampleOrderNV( CoarseSampleOrderTypeNV sampleOrderType,
18831 uint32_t customSampleOrderCount,
18832 const CoarseSampleOrderCustomNV * pCustomSampleOrders,
18833 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
18834 {
18835 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
18836 d.vkCmdSetCoarseSampleOrderNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
18837 static_cast<VkCoarseSampleOrderTypeNV>( sampleOrderType ),
18838 customSampleOrderCount,
18839 reinterpret_cast<const VkCoarseSampleOrderCustomNV *>( pCustomSampleOrders ) );
18840 }
18841
18842 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
18843 // wrapper function for command vkCmdSetCoarseSampleOrderNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoarseSampleOrderNV.html
18844 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
18845 VULKAN_HPP_INLINE void CommandBuffer::setCoarseSampleOrderNV( CoarseSampleOrderTypeNV sampleOrderType,
18846 ArrayProxy<const CoarseSampleOrderCustomNV> const & customSampleOrders,
18847 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
18848 {
18849 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
18850 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
18851 VULKAN_HPP_ASSERT( d.vkCmdSetCoarseSampleOrderNV && "Function <vkCmdSetCoarseSampleOrderNV> requires <VK_NV_shading_rate_image>" );
18852 # endif
18853
18854 d.vkCmdSetCoarseSampleOrderNV( m_commandBuffer,
18855 static_cast<VkCoarseSampleOrderTypeNV>( sampleOrderType ),
18856 customSampleOrders.size(),
18857 reinterpret_cast<const VkCoarseSampleOrderCustomNV *>( customSampleOrders.data() ) );
18858 }
18859 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
18860
18861 //=== VK_NV_ray_tracing ===
18862
18863 // wrapper function for command vkCreateAccelerationStructureNV, see
18864 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAccelerationStructureNV.html
18865 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
18866 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createAccelerationStructureNV( const AccelerationStructureCreateInfoNV * pCreateInfo,
18867 const AllocationCallbacks * pAllocator,
18868 AccelerationStructureNV * pAccelerationStructure,
18869 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
18870 {
18871 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
18872 return static_cast<Result>( d.vkCreateAccelerationStructureNV( static_cast<VkDevice>( m_device ),
18873 reinterpret_cast<const VkAccelerationStructureCreateInfoNV *>( pCreateInfo ),
18874 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
18875 reinterpret_cast<VkAccelerationStructureNV *>( pAccelerationStructure ) ) );
18876 }
18877
18878 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
18879 // wrapper function for command vkCreateAccelerationStructureNV, see
18880 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAccelerationStructureNV.html
18881 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
18882 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<AccelerationStructureNV>::type Device::createAccelerationStructureNV(
18883 const AccelerationStructureCreateInfoNV & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
18884 {
18885 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
18886 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
18887 VULKAN_HPP_ASSERT( d.vkCreateAccelerationStructureNV && "Function <vkCreateAccelerationStructureNV> requires <VK_NV_ray_tracing>" );
18888 # endif
18889
18890 AccelerationStructureNV accelerationStructure;
18891 Result result = static_cast<Result>( d.vkCreateAccelerationStructureNV( m_device,
18892 reinterpret_cast<const VkAccelerationStructureCreateInfoNV *>( &createInfo ),
18893 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
18894 reinterpret_cast<VkAccelerationStructureNV *>( &accelerationStructure ) ) );
18895 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createAccelerationStructureNV" );
18896
18897 return detail::createResultValueType( result, std::move( accelerationStructure ) );
18898 }
18899
18900 # ifndef VULKAN_HPP_NO_SMART_HANDLE
18901 // wrapper function for command vkCreateAccelerationStructureNV, see
18902 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAccelerationStructureNV.html
18903 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
18904 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<AccelerationStructureNV, Dispatch>>::type
18905 Device::createAccelerationStructureNVUnique( const AccelerationStructureCreateInfoNV & createInfo,
18906 Optional<const AllocationCallbacks> allocator,
18907 Dispatch const & d ) const
18908 {
18909 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
18910 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
18911 VULKAN_HPP_ASSERT( d.vkCreateAccelerationStructureNV && "Function <vkCreateAccelerationStructureNV> requires <VK_NV_ray_tracing>" );
18912 # endif
18913
18914 AccelerationStructureNV accelerationStructure;
18915 Result result = static_cast<Result>( d.vkCreateAccelerationStructureNV( m_device,
18916 reinterpret_cast<const VkAccelerationStructureCreateInfoNV *>( &createInfo ),
18917 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
18918 reinterpret_cast<VkAccelerationStructureNV *>( &accelerationStructure ) ) );
18919 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createAccelerationStructureNVUnique" );
18920
18921 return detail::createResultValueType(
18922 result, UniqueHandle<AccelerationStructureNV, Dispatch>( accelerationStructure, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
18923 }
18924 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
18925 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
18926
18927 // wrapper function for command vkDestroyAccelerationStructureNV, see
18928 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyAccelerationStructureNV.html
18929 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
18930 VULKAN_HPP_INLINE void Device::destroyAccelerationStructureNV( AccelerationStructureNV accelerationStructure,
18931 const AllocationCallbacks * pAllocator,
18932 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
18933 {
18934 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
18935 d.vkDestroyAccelerationStructureNV( static_cast<VkDevice>( m_device ),
18936 static_cast<VkAccelerationStructureNV>( accelerationStructure ),
18937 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
18938 }
18939
18940 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
18941 // wrapper function for command vkDestroyAccelerationStructureNV, see
18942 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyAccelerationStructureNV.html
18943 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
18944 VULKAN_HPP_INLINE void Device::destroyAccelerationStructureNV( AccelerationStructureNV accelerationStructure,
18945 Optional<const AllocationCallbacks> allocator,
18946 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
18947 {
18948 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
18949 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
18950 VULKAN_HPP_ASSERT( d.vkDestroyAccelerationStructureNV && "Function <vkDestroyAccelerationStructureNV> requires <VK_NV_ray_tracing>" );
18951 # endif
18952
18953 d.vkDestroyAccelerationStructureNV(
18954 m_device, static_cast<VkAccelerationStructureNV>( accelerationStructure ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
18955 }
18956 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
18957
18958 // wrapper function for command vkDestroyAccelerationStructureNV, see
18959 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyAccelerationStructureNV.html
18960 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
18961 VULKAN_HPP_INLINE void
18962 Device::destroy( AccelerationStructureNV accelerationStructure, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
18963 {
18964 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
18965 d.vkDestroyAccelerationStructureNV( static_cast<VkDevice>( m_device ),
18966 static_cast<VkAccelerationStructureNV>( accelerationStructure ),
18967 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
18968 }
18969
18970 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
18971 // wrapper function for command vkDestroyAccelerationStructureNV, see
18972 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyAccelerationStructureNV.html
18973 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
18974 VULKAN_HPP_INLINE void Device::destroy( AccelerationStructureNV accelerationStructure,
18975 Optional<const AllocationCallbacks> allocator,
18976 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
18977 {
18978 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
18979 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
18980 VULKAN_HPP_ASSERT( d.vkDestroyAccelerationStructureNV && "Function <vkDestroyAccelerationStructureNV> requires <VK_NV_ray_tracing>" );
18981 # endif
18982
18983 d.vkDestroyAccelerationStructureNV(
18984 m_device, static_cast<VkAccelerationStructureNV>( accelerationStructure ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
18985 }
18986 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
18987
18988 // wrapper function for command vkGetAccelerationStructureMemoryRequirementsNV, see
18989 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureMemoryRequirementsNV.html
18990 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
18991 VULKAN_HPP_INLINE void Device::getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV * pInfo,
18992 MemoryRequirements2KHR * pMemoryRequirements,
18993 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
18994 {
18995 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
18996 d.vkGetAccelerationStructureMemoryRequirementsNV( static_cast<VkDevice>( m_device ),
18997 reinterpret_cast<const VkAccelerationStructureMemoryRequirementsInfoNV *>( pInfo ),
18998 reinterpret_cast<VkMemoryRequirements2KHR *>( pMemoryRequirements ) );
18999 }
19000
19001 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
19002 // wrapper function for command vkGetAccelerationStructureMemoryRequirementsNV, see
19003 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureMemoryRequirementsNV.html
19004 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
19005 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2KHR Device::getAccelerationStructureMemoryRequirementsNV(
19006 const AccelerationStructureMemoryRequirementsInfoNV & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
19007 {
19008 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
19009 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
19010 VULKAN_HPP_ASSERT( d.vkGetAccelerationStructureMemoryRequirementsNV &&
19011 "Function <vkGetAccelerationStructureMemoryRequirementsNV> requires <VK_NV_ray_tracing>" );
19012 # endif
19013
19014 MemoryRequirements2KHR memoryRequirements;
19015 d.vkGetAccelerationStructureMemoryRequirementsNV( m_device,
19016 reinterpret_cast<const VkAccelerationStructureMemoryRequirementsInfoNV *>( &info ),
19017 reinterpret_cast<VkMemoryRequirements2KHR *>( &memoryRequirements ) );
19018
19019 return memoryRequirements;
19020 }
19021
19022 // wrapper function for command vkGetAccelerationStructureMemoryRequirementsNV, see
19023 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureMemoryRequirementsNV.html
19024 template <typename X, typename Y, typename... Z, typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
19025 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...>
19026 Device::getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV & info,
19027 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
19028 {
19029 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
19030 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
19031 VULKAN_HPP_ASSERT( d.vkGetAccelerationStructureMemoryRequirementsNV &&
19032 "Function <vkGetAccelerationStructureMemoryRequirementsNV> requires <VK_NV_ray_tracing>" );
19033 # endif
19034
19035 StructureChain<X, Y, Z...> structureChain;
19036 MemoryRequirements2KHR & memoryRequirements = structureChain.template get<MemoryRequirements2KHR>();
19037 d.vkGetAccelerationStructureMemoryRequirementsNV( m_device,
19038 reinterpret_cast<const VkAccelerationStructureMemoryRequirementsInfoNV *>( &info ),
19039 reinterpret_cast<VkMemoryRequirements2KHR *>( &memoryRequirements ) );
19040
19041 return structureChain;
19042 }
19043 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
19044
19045 // wrapper function for command vkBindAccelerationStructureMemoryNV, see
19046 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindAccelerationStructureMemoryNV.html
19047 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
19048 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::bindAccelerationStructureMemoryNV( uint32_t bindInfoCount,
19049 const BindAccelerationStructureMemoryInfoNV * pBindInfos,
19050 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
19051 {
19052 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
19053 return static_cast<Result>( d.vkBindAccelerationStructureMemoryNV(
19054 static_cast<VkDevice>( m_device ), bindInfoCount, reinterpret_cast<const VkBindAccelerationStructureMemoryInfoNV *>( pBindInfos ) ) );
19055 }
19056
19057 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
19058 // wrapper function for command vkBindAccelerationStructureMemoryNV, see
19059 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindAccelerationStructureMemoryNV.html
19060 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
19061 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
19062 Device::bindAccelerationStructureMemoryNV( ArrayProxy<const BindAccelerationStructureMemoryInfoNV> const & bindInfos, Dispatch const & d ) const
19063 {
19064 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
19065 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
19066 VULKAN_HPP_ASSERT( d.vkBindAccelerationStructureMemoryNV && "Function <vkBindAccelerationStructureMemoryNV> requires <VK_NV_ray_tracing>" );
19067 # endif
19068
19069 Result result = static_cast<Result>( d.vkBindAccelerationStructureMemoryNV(
19070 m_device, bindInfos.size(), reinterpret_cast<const VkBindAccelerationStructureMemoryInfoNV *>( bindInfos.data() ) ) );
19071 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindAccelerationStructureMemoryNV" );
19072
19073 return detail::createResultValueType( result );
19074 }
19075 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
19076
19077 // wrapper function for command vkCmdBuildAccelerationStructureNV, see
19078 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildAccelerationStructureNV.html
19079 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
19080 VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructureNV( const AccelerationStructureInfoNV * pInfo,
19081 Buffer instanceData,
19082 DeviceSize instanceOffset,
19083 Bool32 update,
19084 AccelerationStructureNV dst,
19085 AccelerationStructureNV src,
19086 Buffer scratch,
19087 DeviceSize scratchOffset,
19088 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
19089 {
19090 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
19091 d.vkCmdBuildAccelerationStructureNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
19092 reinterpret_cast<const VkAccelerationStructureInfoNV *>( pInfo ),
19093 static_cast<VkBuffer>( instanceData ),
19094 static_cast<VkDeviceSize>( instanceOffset ),
19095 static_cast<VkBool32>( update ),
19096 static_cast<VkAccelerationStructureNV>( dst ),
19097 static_cast<VkAccelerationStructureNV>( src ),
19098 static_cast<VkBuffer>( scratch ),
19099 static_cast<VkDeviceSize>( scratchOffset ) );
19100 }
19101
19102 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
19103 // wrapper function for command vkCmdBuildAccelerationStructureNV, see
19104 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildAccelerationStructureNV.html
19105 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
19106 VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructureNV( const AccelerationStructureInfoNV & info,
19107 Buffer instanceData,
19108 DeviceSize instanceOffset,
19109 Bool32 update,
19110 AccelerationStructureNV dst,
19111 AccelerationStructureNV src,
19112 Buffer scratch,
19113 DeviceSize scratchOffset,
19114 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
19115 {
19116 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
19117 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
19118 VULKAN_HPP_ASSERT( d.vkCmdBuildAccelerationStructureNV && "Function <vkCmdBuildAccelerationStructureNV> requires <VK_NV_ray_tracing>" );
19119 # endif
19120
19121 d.vkCmdBuildAccelerationStructureNV( m_commandBuffer,
19122 reinterpret_cast<const VkAccelerationStructureInfoNV *>( &info ),
19123 static_cast<VkBuffer>( instanceData ),
19124 static_cast<VkDeviceSize>( instanceOffset ),
19125 static_cast<VkBool32>( update ),
19126 static_cast<VkAccelerationStructureNV>( dst ),
19127 static_cast<VkAccelerationStructureNV>( src ),
19128 static_cast<VkBuffer>( scratch ),
19129 static_cast<VkDeviceSize>( scratchOffset ) );
19130 }
19131 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
19132
19133 // wrapper function for command vkCmdCopyAccelerationStructureNV, see
19134 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyAccelerationStructureNV.html
19135 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
19136 VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureNV( AccelerationStructureNV dst,
19137 AccelerationStructureNV src,
19138 CopyAccelerationStructureModeKHR mode,
19139 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
19140 {
19141 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
19142 d.vkCmdCopyAccelerationStructureNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
19143 static_cast<VkAccelerationStructureNV>( dst ),
19144 static_cast<VkAccelerationStructureNV>( src ),
19145 static_cast<VkCopyAccelerationStructureModeKHR>( mode ) );
19146 }
19147
19148 // wrapper function for command vkCmdTraceRaysNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdTraceRaysNV.html
19149 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
19150 VULKAN_HPP_INLINE void CommandBuffer::traceRaysNV( Buffer raygenShaderBindingTableBuffer,
19151 DeviceSize raygenShaderBindingOffset,
19152 Buffer missShaderBindingTableBuffer,
19153 DeviceSize missShaderBindingOffset,
19154 DeviceSize missShaderBindingStride,
19155 Buffer hitShaderBindingTableBuffer,
19156 DeviceSize hitShaderBindingOffset,
19157 DeviceSize hitShaderBindingStride,
19158 Buffer callableShaderBindingTableBuffer,
19159 DeviceSize callableShaderBindingOffset,
19160 DeviceSize callableShaderBindingStride,
19161 uint32_t width,
19162 uint32_t height,
19163 uint32_t depth,
19164 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
19165 {
19166 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
19167 d.vkCmdTraceRaysNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
19168 static_cast<VkBuffer>( raygenShaderBindingTableBuffer ),
19169 static_cast<VkDeviceSize>( raygenShaderBindingOffset ),
19170 static_cast<VkBuffer>( missShaderBindingTableBuffer ),
19171 static_cast<VkDeviceSize>( missShaderBindingOffset ),
19172 static_cast<VkDeviceSize>( missShaderBindingStride ),
19173 static_cast<VkBuffer>( hitShaderBindingTableBuffer ),
19174 static_cast<VkDeviceSize>( hitShaderBindingOffset ),
19175 static_cast<VkDeviceSize>( hitShaderBindingStride ),
19176 static_cast<VkBuffer>( callableShaderBindingTableBuffer ),
19177 static_cast<VkDeviceSize>( callableShaderBindingOffset ),
19178 static_cast<VkDeviceSize>( callableShaderBindingStride ),
19179 width,
19180 height,
19181 depth );
19182 }
19183
19184 // wrapper function for command vkCreateRayTracingPipelinesNV, see
19185 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesNV.html
19186 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
19187 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createRayTracingPipelinesNV( PipelineCache pipelineCache,
19188 uint32_t createInfoCount,
19189 const RayTracingPipelineCreateInfoNV * pCreateInfos,
19190 const AllocationCallbacks * pAllocator,
19191 Pipeline * pPipelines,
19192 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
19193 {
19194 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
19195 return static_cast<Result>( d.vkCreateRayTracingPipelinesNV( static_cast<VkDevice>( m_device ),
19196 static_cast<VkPipelineCache>( pipelineCache ),
19197 createInfoCount,
19198 reinterpret_cast<const VkRayTracingPipelineCreateInfoNV *>( pCreateInfos ),
19199 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
19200 reinterpret_cast<VkPipeline *>( pPipelines ) ) );
19201 }
19202
19203 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
19204 // wrapper function for command vkCreateRayTracingPipelinesNV, see
19205 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesNV.html
19206 template <typename PipelineAllocator,
19207 typename Dispatch,
19208 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, Pipeline>::value, int>::type,
19209 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
19210 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<Pipeline, PipelineAllocator>>
19211 Device::createRayTracingPipelinesNV( PipelineCache pipelineCache,
19212 ArrayProxy<const RayTracingPipelineCreateInfoNV> const & createInfos,
19213 Optional<const AllocationCallbacks> allocator,
19214 Dispatch const & d ) const
19215 {
19216 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
19217 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
19218 VULKAN_HPP_ASSERT( d.vkCreateRayTracingPipelinesNV && "Function <vkCreateRayTracingPipelinesNV> requires <VK_NV_ray_tracing>" );
19219 # endif
19220
19221 std::vector<Pipeline, PipelineAllocator> pipelines( createInfos.size() );
19222 Result result = static_cast<Result>( d.vkCreateRayTracingPipelinesNV( m_device,
19223 static_cast<VkPipelineCache>( pipelineCache ),
19224 createInfos.size(),
19225 reinterpret_cast<const VkRayTracingPipelineCreateInfoNV *>( createInfos.data() ),
19226 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
19227 reinterpret_cast<VkPipeline *>( pipelines.data() ) ) );
19228 detail::resultCheck(
19229 result, VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesNV", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } );
19230
19231 return ResultValue<std::vector<Pipeline, PipelineAllocator>>( result, std::move( pipelines ) );
19232 }
19233
19234 // wrapper function for command vkCreateRayTracingPipelinesNV, see
19235 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesNV.html
19236 template <typename PipelineAllocator,
19237 typename Dispatch,
19238 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, Pipeline>::value, int>::type,
19239 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
19240 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<Pipeline, PipelineAllocator>>
19241 Device::createRayTracingPipelinesNV( PipelineCache pipelineCache,
19242 ArrayProxy<const RayTracingPipelineCreateInfoNV> const & createInfos,
19243 Optional<const AllocationCallbacks> allocator,
19244 PipelineAllocator & pipelineAllocator,
19245 Dispatch const & d ) const
19246 {
19247 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
19248 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
19249 VULKAN_HPP_ASSERT( d.vkCreateRayTracingPipelinesNV && "Function <vkCreateRayTracingPipelinesNV> requires <VK_NV_ray_tracing>" );
19250 # endif
19251
19252 std::vector<Pipeline, PipelineAllocator> pipelines( createInfos.size(), pipelineAllocator );
19253 Result result = static_cast<Result>( d.vkCreateRayTracingPipelinesNV( m_device,
19254 static_cast<VkPipelineCache>( pipelineCache ),
19255 createInfos.size(),
19256 reinterpret_cast<const VkRayTracingPipelineCreateInfoNV *>( createInfos.data() ),
19257 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
19258 reinterpret_cast<VkPipeline *>( pipelines.data() ) ) );
19259 detail::resultCheck(
19260 result, VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesNV", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } );
19261
19262 return ResultValue<std::vector<Pipeline, PipelineAllocator>>( result, std::move( pipelines ) );
19263 }
19264
19265 // wrapper function for command vkCreateRayTracingPipelinesNV, see
19266 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesNV.html
19267 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
19268 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<Pipeline> Device::createRayTracingPipelineNV( PipelineCache pipelineCache,
19269 const RayTracingPipelineCreateInfoNV & createInfo,
19270 Optional<const AllocationCallbacks> allocator,
19271 Dispatch const & d ) const
19272 {
19273 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
19274 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
19275 VULKAN_HPP_ASSERT( d.vkCreateRayTracingPipelinesNV && "Function <vkCreateRayTracingPipelinesNV> requires <VK_NV_ray_tracing>" );
19276 # endif
19277
19278 Pipeline pipeline;
19279 Result result = static_cast<Result>( d.vkCreateRayTracingPipelinesNV( m_device,
19280 static_cast<VkPipelineCache>( pipelineCache ),
19281 1,
19282 reinterpret_cast<const VkRayTracingPipelineCreateInfoNV *>( &createInfo ),
19283 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
19284 reinterpret_cast<VkPipeline *>( &pipeline ) ) );
19285 detail::resultCheck(
19286 result, VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelineNV", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } );
19287
19288 return ResultValue<Pipeline>( result, std::move( pipeline ) );
19289 }
19290
19291 # ifndef VULKAN_HPP_NO_SMART_HANDLE
19292 // wrapper function for command vkCreateRayTracingPipelinesNV, see
19293 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesNV.html
19294 template <typename Dispatch,
19295 typename PipelineAllocator,
19296 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<Pipeline, Dispatch>>::value, int>::type,
19297 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
19298 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
19299 Device::createRayTracingPipelinesNVUnique( PipelineCache pipelineCache,
19300 ArrayProxy<const RayTracingPipelineCreateInfoNV> const & createInfos,
19301 Optional<const AllocationCallbacks> allocator,
19302 Dispatch const & d ) const
19303 {
19304 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
19305 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
19306 VULKAN_HPP_ASSERT( d.vkCreateRayTracingPipelinesNV && "Function <vkCreateRayTracingPipelinesNV> requires <VK_NV_ray_tracing>" );
19307 # endif
19308
19309 std::vector<Pipeline> pipelines( createInfos.size() );
19310 Result result = static_cast<Result>( d.vkCreateRayTracingPipelinesNV( m_device,
19311 static_cast<VkPipelineCache>( pipelineCache ),
19312 createInfos.size(),
19313 reinterpret_cast<const VkRayTracingPipelineCreateInfoNV *>( createInfos.data() ),
19314 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
19315 reinterpret_cast<VkPipeline *>( pipelines.data() ) ) );
19316 detail::resultCheck(
19317 result, VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesNVUnique", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } );
19318 std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator> uniquePipelines;
19319 uniquePipelines.reserve( createInfos.size() );
19320 detail::ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
19321 for ( auto const & pipeline : pipelines )
19322 {
19323 uniquePipelines.push_back( UniqueHandle<Pipeline, Dispatch>( pipeline, deleter ) );
19324 }
19325 return ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>( result, std::move( uniquePipelines ) );
19326 }
19327
19328 // wrapper function for command vkCreateRayTracingPipelinesNV, see
19329 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesNV.html
19330 template <typename Dispatch,
19331 typename PipelineAllocator,
19332 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<Pipeline, Dispatch>>::value, int>::type,
19333 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
19334 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
19335 Device::createRayTracingPipelinesNVUnique( PipelineCache pipelineCache,
19336 ArrayProxy<const RayTracingPipelineCreateInfoNV> const & createInfos,
19337 Optional<const AllocationCallbacks> allocator,
19338 PipelineAllocator & pipelineAllocator,
19339 Dispatch const & d ) const
19340 {
19341 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
19342 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
19343 VULKAN_HPP_ASSERT( d.vkCreateRayTracingPipelinesNV && "Function <vkCreateRayTracingPipelinesNV> requires <VK_NV_ray_tracing>" );
19344 # endif
19345
19346 std::vector<Pipeline> pipelines( createInfos.size() );
19347 Result result = static_cast<Result>( d.vkCreateRayTracingPipelinesNV( m_device,
19348 static_cast<VkPipelineCache>( pipelineCache ),
19349 createInfos.size(),
19350 reinterpret_cast<const VkRayTracingPipelineCreateInfoNV *>( createInfos.data() ),
19351 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
19352 reinterpret_cast<VkPipeline *>( pipelines.data() ) ) );
19353 detail::resultCheck(
19354 result, VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesNVUnique", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } );
19355 std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator> uniquePipelines( pipelineAllocator );
19356 uniquePipelines.reserve( createInfos.size() );
19357 detail::ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
19358 for ( auto const & pipeline : pipelines )
19359 {
19360 uniquePipelines.push_back( UniqueHandle<Pipeline, Dispatch>( pipeline, deleter ) );
19361 }
19362 return ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>( result, std::move( uniquePipelines ) );
19363 }
19364
19365 // wrapper function for command vkCreateRayTracingPipelinesNV, see
19366 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesNV.html
19367 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
19368 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<UniqueHandle<Pipeline, Dispatch>> Device::createRayTracingPipelineNVUnique(
19369 PipelineCache pipelineCache, const RayTracingPipelineCreateInfoNV & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
19370 {
19371 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
19372 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
19373 VULKAN_HPP_ASSERT( d.vkCreateRayTracingPipelinesNV && "Function <vkCreateRayTracingPipelinesNV> requires <VK_NV_ray_tracing>" );
19374 # endif
19375
19376 Pipeline pipeline;
19377 Result result = static_cast<Result>( d.vkCreateRayTracingPipelinesNV( m_device,
19378 static_cast<VkPipelineCache>( pipelineCache ),
19379 1,
19380 reinterpret_cast<const VkRayTracingPipelineCreateInfoNV *>( &createInfo ),
19381 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
19382 reinterpret_cast<VkPipeline *>( &pipeline ) ) );
19383 detail::resultCheck(
19384 result, VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelineNVUnique", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } );
19385
19386 return ResultValue<UniqueHandle<Pipeline, Dispatch>>(
19387 result, UniqueHandle<Pipeline, Dispatch>( pipeline, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
19388 }
19389 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
19390 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
19391
19392 // wrapper function for command vkGetRayTracingShaderGroupHandlesNV, see
19393 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupHandlesNV.html
19394 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
19395 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getRayTracingShaderGroupHandlesNV(
19396 Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void * pData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
19397 {
19398 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
19399 return static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesNV(
19400 static_cast<VkDevice>( m_device ), static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, dataSize, pData ) );
19401 }
19402
19403 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
19404 // wrapper function for command vkGetRayTracingShaderGroupHandlesNV, see
19405 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupHandlesNV.html
19406 template <typename DataType,
19407 typename DataTypeAllocator,
19408 typename Dispatch,
19409 typename std::enable_if<std::is_same<typename DataTypeAllocator::value_type, DataType>::value, int>::type,
19410 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
19411 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type
19412 Device::getRayTracingShaderGroupHandlesNV( Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, Dispatch const & d ) const
19413 {
19414 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
19415 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
19416 VULKAN_HPP_ASSERT( d.vkGetRayTracingShaderGroupHandlesNV &&
19417 "Function <vkGetRayTracingShaderGroupHandlesNV> requires <VK_KHR_ray_tracing_pipeline> or <VK_NV_ray_tracing>" );
19418 # endif
19419
19420 VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 );
19421 std::vector<DataType, DataTypeAllocator> data( dataSize / sizeof( DataType ) );
19422 Result result = static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesNV(
19423 m_device, static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, data.size() * sizeof( DataType ), reinterpret_cast<void *>( data.data() ) ) );
19424 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandlesNV" );
19425
19426 return detail::createResultValueType( result, std::move( data ) );
19427 }
19428
19429 // wrapper function for command vkGetRayTracingShaderGroupHandlesNV, see
19430 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupHandlesNV.html
19431 template <typename DataType, typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
19432 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<DataType>::type
19433 Device::getRayTracingShaderGroupHandleNV( Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const & d ) const
19434 {
19435 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
19436 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
19437 VULKAN_HPP_ASSERT( d.vkGetRayTracingShaderGroupHandlesNV &&
19438 "Function <vkGetRayTracingShaderGroupHandlesNV> requires <VK_KHR_ray_tracing_pipeline> or <VK_NV_ray_tracing>" );
19439 # endif
19440
19441 DataType data;
19442 Result result = static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesNV(
19443 m_device, static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, sizeof( DataType ), reinterpret_cast<void *>( &data ) ) );
19444 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandleNV" );
19445
19446 return detail::createResultValueType( result, std::move( data ) );
19447 }
19448 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
19449
19450 // wrapper function for command vkGetAccelerationStructureHandleNV, see
19451 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureHandleNV.html
19452 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
19453 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getAccelerationStructureHandleNV( AccelerationStructureNV accelerationStructure,
19454 size_t dataSize,
19455 void * pData,
19456 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
19457 {
19458 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
19459 return static_cast<Result>( d.vkGetAccelerationStructureHandleNV(
19460 static_cast<VkDevice>( m_device ), static_cast<VkAccelerationStructureNV>( accelerationStructure ), dataSize, pData ) );
19461 }
19462
19463 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
19464 // wrapper function for command vkGetAccelerationStructureHandleNV, see
19465 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureHandleNV.html
19466 template <typename DataType,
19467 typename DataTypeAllocator,
19468 typename Dispatch,
19469 typename std::enable_if<std::is_same<typename DataTypeAllocator::value_type, DataType>::value, int>::type,
19470 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
19471 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type
19472 Device::getAccelerationStructureHandleNV( AccelerationStructureNV accelerationStructure, size_t dataSize, Dispatch const & d ) const
19473 {
19474 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
19475 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
19476 VULKAN_HPP_ASSERT( d.vkGetAccelerationStructureHandleNV && "Function <vkGetAccelerationStructureHandleNV> requires <VK_NV_ray_tracing>" );
19477 # endif
19478
19479 VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 );
19480 std::vector<DataType, DataTypeAllocator> data( dataSize / sizeof( DataType ) );
19481 Result result = static_cast<Result>( d.vkGetAccelerationStructureHandleNV(
19482 m_device, static_cast<VkAccelerationStructureNV>( accelerationStructure ), data.size() * sizeof( DataType ), reinterpret_cast<void *>( data.data() ) ) );
19483 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getAccelerationStructureHandleNV" );
19484
19485 return detail::createResultValueType( result, std::move( data ) );
19486 }
19487
19488 // wrapper function for command vkGetAccelerationStructureHandleNV, see
19489 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureHandleNV.html
19490 template <typename DataType, typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
19491 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<DataType>::type
19492 Device::getAccelerationStructureHandleNV( AccelerationStructureNV accelerationStructure, Dispatch const & d ) const
19493 {
19494 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
19495 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
19496 VULKAN_HPP_ASSERT( d.vkGetAccelerationStructureHandleNV && "Function <vkGetAccelerationStructureHandleNV> requires <VK_NV_ray_tracing>" );
19497 # endif
19498
19499 DataType data;
19500 Result result = static_cast<Result>( d.vkGetAccelerationStructureHandleNV(
19501 m_device, static_cast<VkAccelerationStructureNV>( accelerationStructure ), sizeof( DataType ), reinterpret_cast<void *>( &data ) ) );
19502 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getAccelerationStructureHandleNV" );
19503
19504 return detail::createResultValueType( result, std::move( data ) );
19505 }
19506 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
19507
19508 // wrapper function for command vkCmdWriteAccelerationStructuresPropertiesNV, see
19509 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteAccelerationStructuresPropertiesNV.html
19510 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
19511 VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesNV( uint32_t accelerationStructureCount,
19512 const AccelerationStructureNV * pAccelerationStructures,
19513 QueryType queryType,
19514 QueryPool queryPool,
19515 uint32_t firstQuery,
19516 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
19517 {
19518 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
19519 d.vkCmdWriteAccelerationStructuresPropertiesNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
19520 accelerationStructureCount,
19521 reinterpret_cast<const VkAccelerationStructureNV *>( pAccelerationStructures ),
19522 static_cast<VkQueryType>( queryType ),
19523 static_cast<VkQueryPool>( queryPool ),
19524 firstQuery );
19525 }
19526
19527 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
19528 // wrapper function for command vkCmdWriteAccelerationStructuresPropertiesNV, see
19529 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteAccelerationStructuresPropertiesNV.html
19530 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
19531 VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesNV( ArrayProxy<const AccelerationStructureNV> const & accelerationStructures,
19532 QueryType queryType,
19533 QueryPool queryPool,
19534 uint32_t firstQuery,
19535 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
19536 {
19537 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
19538 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
19539 VULKAN_HPP_ASSERT( d.vkCmdWriteAccelerationStructuresPropertiesNV &&
19540 "Function <vkCmdWriteAccelerationStructuresPropertiesNV> requires <VK_NV_ray_tracing>" );
19541 # endif
19542
19543 d.vkCmdWriteAccelerationStructuresPropertiesNV( m_commandBuffer,
19544 accelerationStructures.size(),
19545 reinterpret_cast<const VkAccelerationStructureNV *>( accelerationStructures.data() ),
19546 static_cast<VkQueryType>( queryType ),
19547 static_cast<VkQueryPool>( queryPool ),
19548 firstQuery );
19549 }
19550 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
19551
19552 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
19553 // wrapper function for command vkCompileDeferredNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCompileDeferredNV.html
19554 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
19555 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::compileDeferredNV( Pipeline pipeline, uint32_t shader, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
19556 {
19557 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
19558 return static_cast<Result>( d.vkCompileDeferredNV( static_cast<VkDevice>( m_device ), static_cast<VkPipeline>( pipeline ), shader ) );
19559 }
19560 #else
19561 // wrapper function for command vkCompileDeferredNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCompileDeferredNV.html
19562 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
19563 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
19564 Device::compileDeferredNV( Pipeline pipeline, uint32_t shader, Dispatch const & d ) const
19565 {
19566 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
19567 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
19568 VULKAN_HPP_ASSERT( d.vkCompileDeferredNV && "Function <vkCompileDeferredNV> requires <VK_NV_ray_tracing>" );
19569 # endif
19570
19571 Result result = static_cast<Result>( d.vkCompileDeferredNV( m_device, static_cast<VkPipeline>( pipeline ), shader ) );
19572 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::compileDeferredNV" );
19573
19574 return detail::createResultValueType( result );
19575 }
19576 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
19577
19578 //=== VK_KHR_maintenance3 ===
19579
19580 // wrapper function for command vkGetDescriptorSetLayoutSupportKHR, see
19581 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSupportKHR.html
19582 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
19583 VULKAN_HPP_INLINE void Device::getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo * pCreateInfo,
19584 DescriptorSetLayoutSupport * pSupport,
19585 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
19586 {
19587 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
19588 d.vkGetDescriptorSetLayoutSupportKHR( static_cast<VkDevice>( m_device ),
19589 reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( pCreateInfo ),
19590 reinterpret_cast<VkDescriptorSetLayoutSupport *>( pSupport ) );
19591 }
19592
19593 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
19594 // wrapper function for command vkGetDescriptorSetLayoutSupportKHR, see
19595 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSupportKHR.html
19596 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
19597 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DescriptorSetLayoutSupport Device::getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo,
19598 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
19599 {
19600 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
19601 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
19602 VULKAN_HPP_ASSERT( d.vkGetDescriptorSetLayoutSupportKHR &&
19603 "Function <vkGetDescriptorSetLayoutSupportKHR> requires <VK_KHR_maintenance3> or <VK_VERSION_1_1>" );
19604 # endif
19605
19606 DescriptorSetLayoutSupport support;
19607 d.vkGetDescriptorSetLayoutSupportKHR(
19608 m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( &createInfo ), reinterpret_cast<VkDescriptorSetLayoutSupport *>( &support ) );
19609
19610 return support;
19611 }
19612
19613 // wrapper function for command vkGetDescriptorSetLayoutSupportKHR, see
19614 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSupportKHR.html
19615 template <typename X, typename Y, typename... Z, typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
19616 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo,
19617 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
19618 {
19619 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
19620 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
19621 VULKAN_HPP_ASSERT( d.vkGetDescriptorSetLayoutSupportKHR &&
19622 "Function <vkGetDescriptorSetLayoutSupportKHR> requires <VK_KHR_maintenance3> or <VK_VERSION_1_1>" );
19623 # endif
19624
19625 StructureChain<X, Y, Z...> structureChain;
19626 DescriptorSetLayoutSupport & support = structureChain.template get<DescriptorSetLayoutSupport>();
19627 d.vkGetDescriptorSetLayoutSupportKHR(
19628 m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( &createInfo ), reinterpret_cast<VkDescriptorSetLayoutSupport *>( &support ) );
19629
19630 return structureChain;
19631 }
19632 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
19633
19634 //=== VK_KHR_draw_indirect_count ===
19635
19636 // wrapper function for command vkCmdDrawIndirectCountKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirectCountKHR.html
19637 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
19638 VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountKHR( Buffer buffer,
19639 DeviceSize offset,
19640 Buffer countBuffer,
19641 DeviceSize countBufferOffset,
19642 uint32_t maxDrawCount,
19643 uint32_t stride,
19644 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
19645 {
19646 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
19647 d.vkCmdDrawIndirectCountKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
19648 static_cast<VkBuffer>( buffer ),
19649 static_cast<VkDeviceSize>( offset ),
19650 static_cast<VkBuffer>( countBuffer ),
19651 static_cast<VkDeviceSize>( countBufferOffset ),
19652 maxDrawCount,
19653 stride );
19654 }
19655
19656 // wrapper function for command vkCmdDrawIndexedIndirectCountKHR, see
19657 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexedIndirectCountKHR.html
19658 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
19659 VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountKHR( Buffer buffer,
19660 DeviceSize offset,
19661 Buffer countBuffer,
19662 DeviceSize countBufferOffset,
19663 uint32_t maxDrawCount,
19664 uint32_t stride,
19665 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
19666 {
19667 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
19668 d.vkCmdDrawIndexedIndirectCountKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
19669 static_cast<VkBuffer>( buffer ),
19670 static_cast<VkDeviceSize>( offset ),
19671 static_cast<VkBuffer>( countBuffer ),
19672 static_cast<VkDeviceSize>( countBufferOffset ),
19673 maxDrawCount,
19674 stride );
19675 }
19676
19677 //=== VK_EXT_external_memory_host ===
19678
19679 // wrapper function for command vkGetMemoryHostPointerPropertiesEXT, see
19680 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryHostPointerPropertiesEXT.html
19681 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
19682 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getMemoryHostPointerPropertiesEXT( ExternalMemoryHandleTypeFlagBits handleType,
19683 const void * pHostPointer,
19684 MemoryHostPointerPropertiesEXT * pMemoryHostPointerProperties,
19685 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
19686 {
19687 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
19688 return static_cast<Result>( d.vkGetMemoryHostPointerPropertiesEXT( static_cast<VkDevice>( m_device ),
19689 static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ),
19690 pHostPointer,
19691 reinterpret_cast<VkMemoryHostPointerPropertiesEXT *>( pMemoryHostPointerProperties ) ) );
19692 }
19693
19694 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
19695 // wrapper function for command vkGetMemoryHostPointerPropertiesEXT, see
19696 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryHostPointerPropertiesEXT.html
19697 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
19698 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<MemoryHostPointerPropertiesEXT>::type
19699 Device::getMemoryHostPointerPropertiesEXT( ExternalMemoryHandleTypeFlagBits handleType, const void * pHostPointer, Dispatch const & d ) const
19700 {
19701 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
19702 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
19703 VULKAN_HPP_ASSERT( d.vkGetMemoryHostPointerPropertiesEXT && "Function <vkGetMemoryHostPointerPropertiesEXT> requires <VK_EXT_external_memory_host>" );
19704 # endif
19705
19706 MemoryHostPointerPropertiesEXT memoryHostPointerProperties;
19707 Result result =
19708 static_cast<Result>( d.vkGetMemoryHostPointerPropertiesEXT( m_device,
19709 static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ),
19710 pHostPointer,
19711 reinterpret_cast<VkMemoryHostPointerPropertiesEXT *>( &memoryHostPointerProperties ) ) );
19712 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryHostPointerPropertiesEXT" );
19713
19714 return detail::createResultValueType( result, std::move( memoryHostPointerProperties ) );
19715 }
19716 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
19717
19718 //=== VK_AMD_buffer_marker ===
19719
19720 // wrapper function for command vkCmdWriteBufferMarkerAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteBufferMarkerAMD.html
19721 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
19722 VULKAN_HPP_INLINE void CommandBuffer::writeBufferMarkerAMD(
19723 PipelineStageFlagBits pipelineStage, Buffer dstBuffer, DeviceSize dstOffset, uint32_t marker, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
19724 {
19725 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
19726 d.vkCmdWriteBufferMarkerAMD( static_cast<VkCommandBuffer>( m_commandBuffer ),
19727 static_cast<VkPipelineStageFlagBits>( pipelineStage ),
19728 static_cast<VkBuffer>( dstBuffer ),
19729 static_cast<VkDeviceSize>( dstOffset ),
19730 marker );
19731 }
19732
19733 // wrapper function for command vkCmdWriteBufferMarker2AMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteBufferMarker2AMD.html
19734 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
19735 VULKAN_HPP_INLINE void CommandBuffer::writeBufferMarker2AMD(
19736 PipelineStageFlags2 stage, Buffer dstBuffer, DeviceSize dstOffset, uint32_t marker, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
19737 {
19738 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
19739 d.vkCmdWriteBufferMarker2AMD( static_cast<VkCommandBuffer>( m_commandBuffer ),
19740 static_cast<VkPipelineStageFlags2>( stage ),
19741 static_cast<VkBuffer>( dstBuffer ),
19742 static_cast<VkDeviceSize>( dstOffset ),
19743 marker );
19744 }
19745
19746 //=== VK_EXT_calibrated_timestamps ===
19747
19748 // wrapper function for command vkGetPhysicalDeviceCalibrateableTimeDomainsEXT, see
19749 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCalibrateableTimeDomainsEXT.html
19750 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
19751 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getCalibrateableTimeDomainsEXT( uint32_t * pTimeDomainCount,
19752 TimeDomainKHR * pTimeDomains,
19753 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
19754 {
19755 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
19756 return static_cast<Result>( d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(
19757 static_cast<VkPhysicalDevice>( m_physicalDevice ), pTimeDomainCount, reinterpret_cast<VkTimeDomainKHR *>( pTimeDomains ) ) );
19758 }
19759
19760 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
19761 // wrapper function for command vkGetPhysicalDeviceCalibrateableTimeDomainsEXT, see
19762 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCalibrateableTimeDomainsEXT.html
19763 template <typename TimeDomainKHRAllocator,
19764 typename Dispatch,
19765 typename std::enable_if<std::is_same<typename TimeDomainKHRAllocator::value_type, TimeDomainKHR>::value, int>::type,
19766 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
19767 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<TimeDomainKHR, TimeDomainKHRAllocator>>::type
19768 PhysicalDevice::getCalibrateableTimeDomainsEXT( Dispatch const & d ) const
19769 {
19770 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
19771 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
19772 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT &&
19773 "Function <vkGetPhysicalDeviceCalibrateableTimeDomainsEXT> requires <VK_EXT_calibrated_timestamps> or <VK_KHR_calibrated_timestamps>" );
19774 # endif
19775
19776 std::vector<TimeDomainKHR, TimeDomainKHRAllocator> timeDomains;
19777 uint32_t timeDomainCount;
19778 Result result;
19779 do
19780 {
19781 result = static_cast<Result>( d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( m_physicalDevice, &timeDomainCount, nullptr ) );
19782 if ( ( result == Result::eSuccess ) && timeDomainCount )
19783 {
19784 timeDomains.resize( timeDomainCount );
19785 result = static_cast<Result>(
19786 d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( m_physicalDevice, &timeDomainCount, reinterpret_cast<VkTimeDomainKHR *>( timeDomains.data() ) ) );
19787 }
19788 } while ( result == Result::eIncomplete );
19789 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCalibrateableTimeDomainsEXT" );
19790 VULKAN_HPP_ASSERT( timeDomainCount <= timeDomains.size() );
19791 if ( timeDomainCount < timeDomains.size() )
19792 {
19793 timeDomains.resize( timeDomainCount );
19794 }
19795 return detail::createResultValueType( result, std::move( timeDomains ) );
19796 }
19797
19798 // wrapper function for command vkGetPhysicalDeviceCalibrateableTimeDomainsEXT, see
19799 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCalibrateableTimeDomainsEXT.html
19800 template <typename TimeDomainKHRAllocator,
19801 typename Dispatch,
19802 typename std::enable_if<std::is_same<typename TimeDomainKHRAllocator::value_type, TimeDomainKHR>::value, int>::type,
19803 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
19804 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<TimeDomainKHR, TimeDomainKHRAllocator>>::type
19805 PhysicalDevice::getCalibrateableTimeDomainsEXT( TimeDomainKHRAllocator & timeDomainKHRAllocator, Dispatch const & d ) const
19806 {
19807 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
19808 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
19809 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT &&
19810 "Function <vkGetPhysicalDeviceCalibrateableTimeDomainsEXT> requires <VK_EXT_calibrated_timestamps> or <VK_KHR_calibrated_timestamps>" );
19811 # endif
19812
19813 std::vector<TimeDomainKHR, TimeDomainKHRAllocator> timeDomains( timeDomainKHRAllocator );
19814 uint32_t timeDomainCount;
19815 Result result;
19816 do
19817 {
19818 result = static_cast<Result>( d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( m_physicalDevice, &timeDomainCount, nullptr ) );
19819 if ( ( result == Result::eSuccess ) && timeDomainCount )
19820 {
19821 timeDomains.resize( timeDomainCount );
19822 result = static_cast<Result>(
19823 d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( m_physicalDevice, &timeDomainCount, reinterpret_cast<VkTimeDomainKHR *>( timeDomains.data() ) ) );
19824 }
19825 } while ( result == Result::eIncomplete );
19826 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCalibrateableTimeDomainsEXT" );
19827 VULKAN_HPP_ASSERT( timeDomainCount <= timeDomains.size() );
19828 if ( timeDomainCount < timeDomains.size() )
19829 {
19830 timeDomains.resize( timeDomainCount );
19831 }
19832 return detail::createResultValueType( result, std::move( timeDomains ) );
19833 }
19834 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
19835
19836 // wrapper function for command vkGetCalibratedTimestampsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsEXT.html
19837 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
19838 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getCalibratedTimestampsEXT( uint32_t timestampCount,
19839 const CalibratedTimestampInfoKHR * pTimestampInfos,
19840 uint64_t * pTimestamps,
19841 uint64_t * pMaxDeviation,
19842 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
19843 {
19844 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
19845 return static_cast<Result>( d.vkGetCalibratedTimestampsEXT( static_cast<VkDevice>( m_device ),
19846 timestampCount,
19847 reinterpret_cast<const VkCalibratedTimestampInfoKHR *>( pTimestampInfos ),
19848 pTimestamps,
19849 pMaxDeviation ) );
19850 }
19851
19852 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
19853 // wrapper function for command vkGetCalibratedTimestampsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsEXT.html
19854 template <typename Uint64_tAllocator,
19855 typename Dispatch,
19856 typename std::enable_if<std::is_same<typename Uint64_tAllocator::value_type, uint64_t>::value, int>::type,
19857 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
19858 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type
19859 Device::getCalibratedTimestampsEXT( ArrayProxy<const CalibratedTimestampInfoKHR> const & timestampInfos, Dispatch const & d ) const
19860 {
19861 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
19862 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
19863 VULKAN_HPP_ASSERT( d.vkGetCalibratedTimestampsEXT &&
19864 "Function <vkGetCalibratedTimestampsEXT> requires <VK_EXT_calibrated_timestamps> or <VK_KHR_calibrated_timestamps>" );
19865 # endif
19866
19867 std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t> data_(
19868 std::piecewise_construct, std::forward_as_tuple( timestampInfos.size() ), std::forward_as_tuple( 0 ) );
19869 std::vector<uint64_t, Uint64_tAllocator> & timestamps = data_.first;
19870 uint64_t & maxDeviation = data_.second;
19871 Result result = static_cast<Result>( d.vkGetCalibratedTimestampsEXT(
19872 m_device, timestampInfos.size(), reinterpret_cast<const VkCalibratedTimestampInfoKHR *>( timestampInfos.data() ), timestamps.data(), &maxDeviation ) );
19873 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsEXT" );
19874
19875 return detail::createResultValueType( result, std::move( data_ ) );
19876 }
19877
19878 // wrapper function for command vkGetCalibratedTimestampsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsEXT.html
19879 template <typename Uint64_tAllocator,
19880 typename Dispatch,
19881 typename std::enable_if<std::is_same<typename Uint64_tAllocator::value_type, uint64_t>::value, int>::type,
19882 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
19883 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type
19884 Device::getCalibratedTimestampsEXT( ArrayProxy<const CalibratedTimestampInfoKHR> const & timestampInfos,
19885 Uint64_tAllocator & uint64_tAllocator,
19886 Dispatch const & d ) const
19887 {
19888 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
19889 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
19890 VULKAN_HPP_ASSERT( d.vkGetCalibratedTimestampsEXT &&
19891 "Function <vkGetCalibratedTimestampsEXT> requires <VK_EXT_calibrated_timestamps> or <VK_KHR_calibrated_timestamps>" );
19892 # endif
19893
19894 std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t> data_(
19895 std::piecewise_construct, std::forward_as_tuple( timestampInfos.size(), uint64_tAllocator ), std::forward_as_tuple( 0 ) );
19896 std::vector<uint64_t, Uint64_tAllocator> & timestamps = data_.first;
19897 uint64_t & maxDeviation = data_.second;
19898 Result result = static_cast<Result>( d.vkGetCalibratedTimestampsEXT(
19899 m_device, timestampInfos.size(), reinterpret_cast<const VkCalibratedTimestampInfoKHR *>( timestampInfos.data() ), timestamps.data(), &maxDeviation ) );
19900 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsEXT" );
19901
19902 return detail::createResultValueType( result, std::move( data_ ) );
19903 }
19904
19905 // wrapper function for command vkGetCalibratedTimestampsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsEXT.html
19906 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
19907 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::pair<uint64_t, uint64_t>>::type
19908 Device::getCalibratedTimestampEXT( const CalibratedTimestampInfoKHR & timestampInfo, Dispatch const & d ) const
19909 {
19910 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
19911 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
19912 VULKAN_HPP_ASSERT( d.vkGetCalibratedTimestampsEXT &&
19913 "Function <vkGetCalibratedTimestampsEXT> requires <VK_EXT_calibrated_timestamps> or <VK_KHR_calibrated_timestamps>" );
19914 # endif
19915
19916 std::pair<uint64_t, uint64_t> data_;
19917 uint64_t & timestamp = data_.first;
19918 uint64_t & maxDeviation = data_.second;
19919 Result result = static_cast<Result>(
19920 d.vkGetCalibratedTimestampsEXT( m_device, 1, reinterpret_cast<const VkCalibratedTimestampInfoKHR *>( &timestampInfo ), &timestamp, &maxDeviation ) );
19921 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampEXT" );
19922
19923 return detail::createResultValueType( result, std::move( data_ ) );
19924 }
19925 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
19926
19927 //=== VK_NV_mesh_shader ===
19928
19929 // wrapper function for command vkCmdDrawMeshTasksNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksNV.html
19930 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
19931 VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksNV( uint32_t taskCount, uint32_t firstTask, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
19932 {
19933 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
19934 d.vkCmdDrawMeshTasksNV( static_cast<VkCommandBuffer>( m_commandBuffer ), taskCount, firstTask );
19935 }
19936
19937 // wrapper function for command vkCmdDrawMeshTasksIndirectNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksIndirectNV.html
19938 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
19939 VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectNV(
19940 Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
19941 {
19942 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
19943 d.vkCmdDrawMeshTasksIndirectNV(
19944 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), drawCount, stride );
19945 }
19946
19947 // wrapper function for command vkCmdDrawMeshTasksIndirectCountNV, see
19948 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksIndirectCountNV.html
19949 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
19950 VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectCountNV( Buffer buffer,
19951 DeviceSize offset,
19952 Buffer countBuffer,
19953 DeviceSize countBufferOffset,
19954 uint32_t maxDrawCount,
19955 uint32_t stride,
19956 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
19957 {
19958 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
19959 d.vkCmdDrawMeshTasksIndirectCountNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
19960 static_cast<VkBuffer>( buffer ),
19961 static_cast<VkDeviceSize>( offset ),
19962 static_cast<VkBuffer>( countBuffer ),
19963 static_cast<VkDeviceSize>( countBufferOffset ),
19964 maxDrawCount,
19965 stride );
19966 }
19967
19968 //=== VK_NV_scissor_exclusive ===
19969
19970 // wrapper function for command vkCmdSetExclusiveScissorEnableNV, see
19971 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetExclusiveScissorEnableNV.html
19972 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
19973 VULKAN_HPP_INLINE void CommandBuffer::setExclusiveScissorEnableNV( uint32_t firstExclusiveScissor,
19974 uint32_t exclusiveScissorCount,
19975 const Bool32 * pExclusiveScissorEnables,
19976 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
19977 {
19978 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
19979 d.vkCmdSetExclusiveScissorEnableNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
19980 firstExclusiveScissor,
19981 exclusiveScissorCount,
19982 reinterpret_cast<const VkBool32 *>( pExclusiveScissorEnables ) );
19983 }
19984
19985 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
19986 // wrapper function for command vkCmdSetExclusiveScissorEnableNV, see
19987 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetExclusiveScissorEnableNV.html
19988 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
19989 VULKAN_HPP_INLINE void CommandBuffer::setExclusiveScissorEnableNV( uint32_t firstExclusiveScissor,
19990 ArrayProxy<const Bool32> const & exclusiveScissorEnables,
19991 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
19992 {
19993 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
19994 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
19995 VULKAN_HPP_ASSERT( d.vkCmdSetExclusiveScissorEnableNV && "Function <vkCmdSetExclusiveScissorEnableNV> requires <VK_NV_scissor_exclusive>" );
19996 # endif
19997
19998 d.vkCmdSetExclusiveScissorEnableNV(
19999 m_commandBuffer, firstExclusiveScissor, exclusiveScissorEnables.size(), reinterpret_cast<const VkBool32 *>( exclusiveScissorEnables.data() ) );
20000 }
20001 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
20002
20003 // wrapper function for command vkCmdSetExclusiveScissorNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetExclusiveScissorNV.html
20004 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
20005 VULKAN_HPP_INLINE void CommandBuffer::setExclusiveScissorNV( uint32_t firstExclusiveScissor,
20006 uint32_t exclusiveScissorCount,
20007 const Rect2D * pExclusiveScissors,
20008 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
20009 {
20010 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
20011 d.vkCmdSetExclusiveScissorNV(
20012 static_cast<VkCommandBuffer>( m_commandBuffer ), firstExclusiveScissor, exclusiveScissorCount, reinterpret_cast<const VkRect2D *>( pExclusiveScissors ) );
20013 }
20014
20015 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
20016 // wrapper function for command vkCmdSetExclusiveScissorNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetExclusiveScissorNV.html
20017 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
20018 VULKAN_HPP_INLINE void CommandBuffer::setExclusiveScissorNV( uint32_t firstExclusiveScissor,
20019 ArrayProxy<const Rect2D> const & exclusiveScissors,
20020 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
20021 {
20022 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
20023 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
20024 VULKAN_HPP_ASSERT( d.vkCmdSetExclusiveScissorNV && "Function <vkCmdSetExclusiveScissorNV> requires <VK_NV_scissor_exclusive>" );
20025 # endif
20026
20027 d.vkCmdSetExclusiveScissorNV(
20028 m_commandBuffer, firstExclusiveScissor, exclusiveScissors.size(), reinterpret_cast<const VkRect2D *>( exclusiveScissors.data() ) );
20029 }
20030 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
20031
20032 //=== VK_NV_device_diagnostic_checkpoints ===
20033
20034 // wrapper function for command vkCmdSetCheckpointNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCheckpointNV.html
20035 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
20036 VULKAN_HPP_INLINE void CommandBuffer::setCheckpointNV( const void * pCheckpointMarker, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
20037 {
20038 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
20039 d.vkCmdSetCheckpointNV( static_cast<VkCommandBuffer>( m_commandBuffer ), pCheckpointMarker );
20040 }
20041
20042 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
20043 // wrapper function for command vkCmdSetCheckpointNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCheckpointNV.html
20044 template <typename CheckpointMarkerType, typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
20045 VULKAN_HPP_INLINE void CommandBuffer::setCheckpointNV( CheckpointMarkerType const & checkpointMarker, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
20046 {
20047 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
20048 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
20049 VULKAN_HPP_ASSERT( d.vkCmdSetCheckpointNV && "Function <vkCmdSetCheckpointNV> requires <VK_NV_device_diagnostic_checkpoints>" );
20050 # endif
20051
20052 d.vkCmdSetCheckpointNV( m_commandBuffer, reinterpret_cast<const void *>( &checkpointMarker ) );
20053 }
20054 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
20055
20056 // wrapper function for command vkGetQueueCheckpointDataNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueueCheckpointDataNV.html
20057 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
20058 VULKAN_HPP_INLINE void
20059 Queue::getCheckpointDataNV( uint32_t * pCheckpointDataCount, CheckpointDataNV * pCheckpointData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
20060 {
20061 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
20062 d.vkGetQueueCheckpointDataNV( static_cast<VkQueue>( m_queue ), pCheckpointDataCount, reinterpret_cast<VkCheckpointDataNV *>( pCheckpointData ) );
20063 }
20064
20065 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
20066 // wrapper function for command vkGetQueueCheckpointDataNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueueCheckpointDataNV.html
20067 template <typename CheckpointDataNVAllocator,
20068 typename Dispatch,
20069 typename std::enable_if<std::is_same<typename CheckpointDataNVAllocator::value_type, CheckpointDataNV>::value, int>::type,
20070 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
20071 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<CheckpointDataNV, CheckpointDataNVAllocator> Queue::getCheckpointDataNV( Dispatch const & d ) const
20072 {
20073 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
20074 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
20075 VULKAN_HPP_ASSERT( d.vkGetQueueCheckpointDataNV && "Function <vkGetQueueCheckpointDataNV> requires <VK_NV_device_diagnostic_checkpoints>" );
20076 # endif
20077
20078 std::vector<CheckpointDataNV, CheckpointDataNVAllocator> checkpointData;
20079 uint32_t checkpointDataCount;
20080 d.vkGetQueueCheckpointDataNV( m_queue, &checkpointDataCount, nullptr );
20081 checkpointData.resize( checkpointDataCount );
20082 d.vkGetQueueCheckpointDataNV( m_queue, &checkpointDataCount, reinterpret_cast<VkCheckpointDataNV *>( checkpointData.data() ) );
20083
20084 VULKAN_HPP_ASSERT( checkpointDataCount <= checkpointData.size() );
20085 if ( checkpointDataCount < checkpointData.size() )
20086 {
20087 checkpointData.resize( checkpointDataCount );
20088 }
20089 return checkpointData;
20090 }
20091
20092 // wrapper function for command vkGetQueueCheckpointDataNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueueCheckpointDataNV.html
20093 template <typename CheckpointDataNVAllocator,
20094 typename Dispatch,
20095 typename std::enable_if<std::is_same<typename CheckpointDataNVAllocator::value_type, CheckpointDataNV>::value, int>::type,
20096 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
20097 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<CheckpointDataNV, CheckpointDataNVAllocator>
20098 Queue::getCheckpointDataNV( CheckpointDataNVAllocator & checkpointDataNVAllocator, Dispatch const & d ) const
20099 {
20100 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
20101 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
20102 VULKAN_HPP_ASSERT( d.vkGetQueueCheckpointDataNV && "Function <vkGetQueueCheckpointDataNV> requires <VK_NV_device_diagnostic_checkpoints>" );
20103 # endif
20104
20105 std::vector<CheckpointDataNV, CheckpointDataNVAllocator> checkpointData( checkpointDataNVAllocator );
20106 uint32_t checkpointDataCount;
20107 d.vkGetQueueCheckpointDataNV( m_queue, &checkpointDataCount, nullptr );
20108 checkpointData.resize( checkpointDataCount );
20109 d.vkGetQueueCheckpointDataNV( m_queue, &checkpointDataCount, reinterpret_cast<VkCheckpointDataNV *>( checkpointData.data() ) );
20110
20111 VULKAN_HPP_ASSERT( checkpointDataCount <= checkpointData.size() );
20112 if ( checkpointDataCount < checkpointData.size() )
20113 {
20114 checkpointData.resize( checkpointDataCount );
20115 }
20116 return checkpointData;
20117 }
20118 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
20119
20120 // wrapper function for command vkGetQueueCheckpointData2NV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueueCheckpointData2NV.html
20121 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
20122 VULKAN_HPP_INLINE void
20123 Queue::getCheckpointData2NV( uint32_t * pCheckpointDataCount, CheckpointData2NV * pCheckpointData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
20124 {
20125 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
20126 d.vkGetQueueCheckpointData2NV( static_cast<VkQueue>( m_queue ), pCheckpointDataCount, reinterpret_cast<VkCheckpointData2NV *>( pCheckpointData ) );
20127 }
20128
20129 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
20130 // wrapper function for command vkGetQueueCheckpointData2NV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueueCheckpointData2NV.html
20131 template <typename CheckpointData2NVAllocator,
20132 typename Dispatch,
20133 typename std::enable_if<std::is_same<typename CheckpointData2NVAllocator::value_type, CheckpointData2NV>::value, int>::type,
20134 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
20135 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<CheckpointData2NV, CheckpointData2NVAllocator> Queue::getCheckpointData2NV( Dispatch const & d ) const
20136 {
20137 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
20138 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
20139 VULKAN_HPP_ASSERT( d.vkGetQueueCheckpointData2NV && "Function <vkGetQueueCheckpointData2NV> requires <VK_NV_device_diagnostic_checkpoints>" );
20140 # endif
20141
20142 std::vector<CheckpointData2NV, CheckpointData2NVAllocator> checkpointData;
20143 uint32_t checkpointDataCount;
20144 d.vkGetQueueCheckpointData2NV( m_queue, &checkpointDataCount, nullptr );
20145 checkpointData.resize( checkpointDataCount );
20146 d.vkGetQueueCheckpointData2NV( m_queue, &checkpointDataCount, reinterpret_cast<VkCheckpointData2NV *>( checkpointData.data() ) );
20147
20148 VULKAN_HPP_ASSERT( checkpointDataCount <= checkpointData.size() );
20149 if ( checkpointDataCount < checkpointData.size() )
20150 {
20151 checkpointData.resize( checkpointDataCount );
20152 }
20153 return checkpointData;
20154 }
20155
20156 // wrapper function for command vkGetQueueCheckpointData2NV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueueCheckpointData2NV.html
20157 template <typename CheckpointData2NVAllocator,
20158 typename Dispatch,
20159 typename std::enable_if<std::is_same<typename CheckpointData2NVAllocator::value_type, CheckpointData2NV>::value, int>::type,
20160 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
20161 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<CheckpointData2NV, CheckpointData2NVAllocator>
20162 Queue::getCheckpointData2NV( CheckpointData2NVAllocator & checkpointData2NVAllocator, Dispatch const & d ) const
20163 {
20164 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
20165 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
20166 VULKAN_HPP_ASSERT( d.vkGetQueueCheckpointData2NV && "Function <vkGetQueueCheckpointData2NV> requires <VK_NV_device_diagnostic_checkpoints>" );
20167 # endif
20168
20169 std::vector<CheckpointData2NV, CheckpointData2NVAllocator> checkpointData( checkpointData2NVAllocator );
20170 uint32_t checkpointDataCount;
20171 d.vkGetQueueCheckpointData2NV( m_queue, &checkpointDataCount, nullptr );
20172 checkpointData.resize( checkpointDataCount );
20173 d.vkGetQueueCheckpointData2NV( m_queue, &checkpointDataCount, reinterpret_cast<VkCheckpointData2NV *>( checkpointData.data() ) );
20174
20175 VULKAN_HPP_ASSERT( checkpointDataCount <= checkpointData.size() );
20176 if ( checkpointDataCount < checkpointData.size() )
20177 {
20178 checkpointData.resize( checkpointDataCount );
20179 }
20180 return checkpointData;
20181 }
20182 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
20183
20184 //=== VK_KHR_timeline_semaphore ===
20185
20186 // wrapper function for command vkGetSemaphoreCounterValueKHR, see
20187 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreCounterValueKHR.html
20188 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
20189 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSemaphoreCounterValueKHR( Semaphore semaphore,
20190 uint64_t * pValue,
20191 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
20192 {
20193 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
20194 return static_cast<Result>( d.vkGetSemaphoreCounterValueKHR( static_cast<VkDevice>( m_device ), static_cast<VkSemaphore>( semaphore ), pValue ) );
20195 }
20196
20197 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
20198 // wrapper function for command vkGetSemaphoreCounterValueKHR, see
20199 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreCounterValueKHR.html
20200 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
20201 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<uint64_t>::type Device::getSemaphoreCounterValueKHR( Semaphore semaphore,
20202 Dispatch const & d ) const
20203 {
20204 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
20205 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
20206 VULKAN_HPP_ASSERT( d.vkGetSemaphoreCounterValueKHR && "Function <vkGetSemaphoreCounterValueKHR> requires <VK_KHR_timeline_semaphore> or <VK_VERSION_1_2>" );
20207 # endif
20208
20209 uint64_t value;
20210 Result result = static_cast<Result>( d.vkGetSemaphoreCounterValueKHR( m_device, static_cast<VkSemaphore>( semaphore ), &value ) );
20211 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreCounterValueKHR" );
20212
20213 return detail::createResultValueType( result, std::move( value ) );
20214 }
20215 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
20216
20217 // wrapper function for command vkWaitSemaphoresKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitSemaphoresKHR.html
20218 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
20219 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::waitSemaphoresKHR( const SemaphoreWaitInfo * pWaitInfo,
20220 uint64_t timeout,
20221 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
20222 {
20223 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
20224 return static_cast<Result>(
20225 d.vkWaitSemaphoresKHR( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkSemaphoreWaitInfo *>( pWaitInfo ), timeout ) );
20226 }
20227
20228 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
20229 // wrapper function for command vkWaitSemaphoresKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitSemaphoresKHR.html
20230 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
20231 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::waitSemaphoresKHR( const SemaphoreWaitInfo & waitInfo, uint64_t timeout, Dispatch const & d ) const
20232 {
20233 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
20234 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
20235 VULKAN_HPP_ASSERT( d.vkWaitSemaphoresKHR && "Function <vkWaitSemaphoresKHR> requires <VK_KHR_timeline_semaphore> or <VK_VERSION_1_2>" );
20236 # endif
20237
20238 Result result = static_cast<Result>( d.vkWaitSemaphoresKHR( m_device, reinterpret_cast<const VkSemaphoreWaitInfo *>( &waitInfo ), timeout ) );
20239 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::waitSemaphoresKHR", { Result::eSuccess, Result::eTimeout } );
20240
20241 return static_cast<Result>( result );
20242 }
20243 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
20244
20245 // wrapper function for command vkSignalSemaphoreKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSignalSemaphoreKHR.html
20246 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
20247 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::signalSemaphoreKHR( const SemaphoreSignalInfo * pSignalInfo,
20248 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
20249 {
20250 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
20251 return static_cast<Result>( d.vkSignalSemaphoreKHR( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkSemaphoreSignalInfo *>( pSignalInfo ) ) );
20252 }
20253
20254 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
20255 // wrapper function for command vkSignalSemaphoreKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSignalSemaphoreKHR.html
20256 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
20257 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
20258 Device::signalSemaphoreKHR( const SemaphoreSignalInfo & signalInfo, Dispatch const & d ) const
20259 {
20260 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
20261 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
20262 VULKAN_HPP_ASSERT( d.vkSignalSemaphoreKHR && "Function <vkSignalSemaphoreKHR> requires <VK_KHR_timeline_semaphore> or <VK_VERSION_1_2>" );
20263 # endif
20264
20265 Result result = static_cast<Result>( d.vkSignalSemaphoreKHR( m_device, reinterpret_cast<const VkSemaphoreSignalInfo *>( &signalInfo ) ) );
20266 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::signalSemaphoreKHR" );
20267
20268 return detail::createResultValueType( result );
20269 }
20270 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
20271
20272 //=== VK_INTEL_performance_query ===
20273
20274 // wrapper function for command vkInitializePerformanceApiINTEL, see
20275 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkInitializePerformanceApiINTEL.html
20276 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
20277 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::initializePerformanceApiINTEL( const InitializePerformanceApiInfoINTEL * pInitializeInfo,
20278 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
20279 {
20280 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
20281 return static_cast<Result>( d.vkInitializePerformanceApiINTEL( static_cast<VkDevice>( m_device ),
20282 reinterpret_cast<const VkInitializePerformanceApiInfoINTEL *>( pInitializeInfo ) ) );
20283 }
20284
20285 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
20286 // wrapper function for command vkInitializePerformanceApiINTEL, see
20287 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkInitializePerformanceApiINTEL.html
20288 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
20289 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
20290 Device::initializePerformanceApiINTEL( const InitializePerformanceApiInfoINTEL & initializeInfo, Dispatch const & d ) const
20291 {
20292 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
20293 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
20294 VULKAN_HPP_ASSERT( d.vkInitializePerformanceApiINTEL && "Function <vkInitializePerformanceApiINTEL> requires <VK_INTEL_performance_query>" );
20295 # endif
20296
20297 Result result =
20298 static_cast<Result>( d.vkInitializePerformanceApiINTEL( m_device, reinterpret_cast<const VkInitializePerformanceApiInfoINTEL *>( &initializeInfo ) ) );
20299 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::initializePerformanceApiINTEL" );
20300
20301 return detail::createResultValueType( result );
20302 }
20303 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
20304
20305 // wrapper function for command vkUninitializePerformanceApiINTEL, see
20306 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUninitializePerformanceApiINTEL.html
20307 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
20308 VULKAN_HPP_INLINE void Device::uninitializePerformanceApiINTEL( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
20309 {
20310 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
20311 d.vkUninitializePerformanceApiINTEL( static_cast<VkDevice>( m_device ) );
20312 }
20313
20314 // wrapper function for command vkCmdSetPerformanceMarkerINTEL, see
20315 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPerformanceMarkerINTEL.html
20316 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
20317 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result CommandBuffer::setPerformanceMarkerINTEL( const PerformanceMarkerInfoINTEL * pMarkerInfo,
20318 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
20319 {
20320 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
20321 return static_cast<Result>( d.vkCmdSetPerformanceMarkerINTEL( static_cast<VkCommandBuffer>( m_commandBuffer ),
20322 reinterpret_cast<const VkPerformanceMarkerInfoINTEL *>( pMarkerInfo ) ) );
20323 }
20324
20325 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
20326 // wrapper function for command vkCmdSetPerformanceMarkerINTEL, see
20327 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPerformanceMarkerINTEL.html
20328 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
20329 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
20330 CommandBuffer::setPerformanceMarkerINTEL( const PerformanceMarkerInfoINTEL & markerInfo, Dispatch const & d ) const
20331 {
20332 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
20333 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
20334 VULKAN_HPP_ASSERT( d.vkCmdSetPerformanceMarkerINTEL && "Function <vkCmdSetPerformanceMarkerINTEL> requires <VK_INTEL_performance_query>" );
20335 # endif
20336
20337 Result result =
20338 static_cast<Result>( d.vkCmdSetPerformanceMarkerINTEL( m_commandBuffer, reinterpret_cast<const VkPerformanceMarkerInfoINTEL *>( &markerInfo ) ) );
20339 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::setPerformanceMarkerINTEL" );
20340
20341 return detail::createResultValueType( result );
20342 }
20343 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
20344
20345 // wrapper function for command vkCmdSetPerformanceStreamMarkerINTEL, see
20346 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPerformanceStreamMarkerINTEL.html
20347 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
20348 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result CommandBuffer::setPerformanceStreamMarkerINTEL( const PerformanceStreamMarkerInfoINTEL * pMarkerInfo,
20349 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
20350 {
20351 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
20352 return static_cast<Result>( d.vkCmdSetPerformanceStreamMarkerINTEL( static_cast<VkCommandBuffer>( m_commandBuffer ),
20353 reinterpret_cast<const VkPerformanceStreamMarkerInfoINTEL *>( pMarkerInfo ) ) );
20354 }
20355
20356 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
20357 // wrapper function for command vkCmdSetPerformanceStreamMarkerINTEL, see
20358 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPerformanceStreamMarkerINTEL.html
20359 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
20360 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
20361 CommandBuffer::setPerformanceStreamMarkerINTEL( const PerformanceStreamMarkerInfoINTEL & markerInfo, Dispatch const & d ) const
20362 {
20363 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
20364 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
20365 VULKAN_HPP_ASSERT( d.vkCmdSetPerformanceStreamMarkerINTEL && "Function <vkCmdSetPerformanceStreamMarkerINTEL> requires <VK_INTEL_performance_query>" );
20366 # endif
20367
20368 Result result = static_cast<Result>(
20369 d.vkCmdSetPerformanceStreamMarkerINTEL( m_commandBuffer, reinterpret_cast<const VkPerformanceStreamMarkerInfoINTEL *>( &markerInfo ) ) );
20370 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::setPerformanceStreamMarkerINTEL" );
20371
20372 return detail::createResultValueType( result );
20373 }
20374 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
20375
20376 // wrapper function for command vkCmdSetPerformanceOverrideINTEL, see
20377 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPerformanceOverrideINTEL.html
20378 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
20379 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result CommandBuffer::setPerformanceOverrideINTEL( const PerformanceOverrideInfoINTEL * pOverrideInfo,
20380 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
20381 {
20382 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
20383 return static_cast<Result>( d.vkCmdSetPerformanceOverrideINTEL( static_cast<VkCommandBuffer>( m_commandBuffer ),
20384 reinterpret_cast<const VkPerformanceOverrideInfoINTEL *>( pOverrideInfo ) ) );
20385 }
20386
20387 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
20388 // wrapper function for command vkCmdSetPerformanceOverrideINTEL, see
20389 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPerformanceOverrideINTEL.html
20390 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
20391 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
20392 CommandBuffer::setPerformanceOverrideINTEL( const PerformanceOverrideInfoINTEL & overrideInfo, Dispatch const & d ) const
20393 {
20394 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
20395 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
20396 VULKAN_HPP_ASSERT( d.vkCmdSetPerformanceOverrideINTEL && "Function <vkCmdSetPerformanceOverrideINTEL> requires <VK_INTEL_performance_query>" );
20397 # endif
20398
20399 Result result =
20400 static_cast<Result>( d.vkCmdSetPerformanceOverrideINTEL( m_commandBuffer, reinterpret_cast<const VkPerformanceOverrideInfoINTEL *>( &overrideInfo ) ) );
20401 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::setPerformanceOverrideINTEL" );
20402
20403 return detail::createResultValueType( result );
20404 }
20405 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
20406
20407 // wrapper function for command vkAcquirePerformanceConfigurationINTEL, see
20408 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquirePerformanceConfigurationINTEL.html
20409 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
20410 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::acquirePerformanceConfigurationINTEL( const PerformanceConfigurationAcquireInfoINTEL * pAcquireInfo,
20411 PerformanceConfigurationINTEL * pConfiguration,
20412 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
20413 {
20414 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
20415 return static_cast<Result>( d.vkAcquirePerformanceConfigurationINTEL( static_cast<VkDevice>( m_device ),
20416 reinterpret_cast<const VkPerformanceConfigurationAcquireInfoINTEL *>( pAcquireInfo ),
20417 reinterpret_cast<VkPerformanceConfigurationINTEL *>( pConfiguration ) ) );
20418 }
20419
20420 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
20421 // wrapper function for command vkAcquirePerformanceConfigurationINTEL, see
20422 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquirePerformanceConfigurationINTEL.html
20423 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
20424 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<PerformanceConfigurationINTEL>::type
20425 Device::acquirePerformanceConfigurationINTEL( const PerformanceConfigurationAcquireInfoINTEL & acquireInfo, Dispatch const & d ) const
20426 {
20427 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
20428 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
20429 VULKAN_HPP_ASSERT( d.vkAcquirePerformanceConfigurationINTEL && "Function <vkAcquirePerformanceConfigurationINTEL> requires <VK_INTEL_performance_query>" );
20430 # endif
20431
20432 PerformanceConfigurationINTEL configuration;
20433 Result result =
20434 static_cast<Result>( d.vkAcquirePerformanceConfigurationINTEL( m_device,
20435 reinterpret_cast<const VkPerformanceConfigurationAcquireInfoINTEL *>( &acquireInfo ),
20436 reinterpret_cast<VkPerformanceConfigurationINTEL *>( &configuration ) ) );
20437 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::acquirePerformanceConfigurationINTEL" );
20438
20439 return detail::createResultValueType( result, std::move( configuration ) );
20440 }
20441
20442 # ifndef VULKAN_HPP_NO_SMART_HANDLE
20443 // wrapper function for command vkAcquirePerformanceConfigurationINTEL, see
20444 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquirePerformanceConfigurationINTEL.html
20445 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
20446 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<PerformanceConfigurationINTEL, Dispatch>>::type
20447 Device::acquirePerformanceConfigurationINTELUnique( const PerformanceConfigurationAcquireInfoINTEL & acquireInfo, Dispatch const & d ) const
20448 {
20449 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
20450 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
20451 VULKAN_HPP_ASSERT( d.vkAcquirePerformanceConfigurationINTEL && "Function <vkAcquirePerformanceConfigurationINTEL> requires <VK_INTEL_performance_query>" );
20452 # endif
20453
20454 PerformanceConfigurationINTEL configuration;
20455 Result result =
20456 static_cast<Result>( d.vkAcquirePerformanceConfigurationINTEL( m_device,
20457 reinterpret_cast<const VkPerformanceConfigurationAcquireInfoINTEL *>( &acquireInfo ),
20458 reinterpret_cast<VkPerformanceConfigurationINTEL *>( &configuration ) ) );
20459 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::acquirePerformanceConfigurationINTELUnique" );
20460
20461 return detail::createResultValueType(
20462 result, UniqueHandle<PerformanceConfigurationINTEL, Dispatch>( configuration, detail::ObjectRelease<Device, Dispatch>( *this, d ) ) );
20463 }
20464 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
20465 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
20466
20467 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
20468 // wrapper function for command vkReleasePerformanceConfigurationINTEL, see
20469 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleasePerformanceConfigurationINTEL.html
20470 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
20471 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::releasePerformanceConfigurationINTEL( PerformanceConfigurationINTEL configuration,
20472 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
20473 {
20474 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
20475 return static_cast<Result>(
20476 d.vkReleasePerformanceConfigurationINTEL( static_cast<VkDevice>( m_device ), static_cast<VkPerformanceConfigurationINTEL>( configuration ) ) );
20477 }
20478 #else
20479 // wrapper function for command vkReleasePerformanceConfigurationINTEL, see
20480 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleasePerformanceConfigurationINTEL.html
20481 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
20482 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
20483 Device::releasePerformanceConfigurationINTEL( PerformanceConfigurationINTEL configuration, Dispatch const & d ) const
20484 {
20485 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
20486 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
20487 VULKAN_HPP_ASSERT( d.vkReleasePerformanceConfigurationINTEL && "Function <vkReleasePerformanceConfigurationINTEL> requires <VK_INTEL_performance_query>" );
20488 # endif
20489
20490 Result result = static_cast<Result>( d.vkReleasePerformanceConfigurationINTEL( m_device, static_cast<VkPerformanceConfigurationINTEL>( configuration ) ) );
20491 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::releasePerformanceConfigurationINTEL" );
20492
20493 return detail::createResultValueType( result );
20494 }
20495 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
20496
20497 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
20498 // wrapper function for command vkReleasePerformanceConfigurationINTEL, see
20499 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleasePerformanceConfigurationINTEL.html
20500 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
20501 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::release( PerformanceConfigurationINTEL configuration, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
20502 {
20503 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
20504 return static_cast<Result>(
20505 d.vkReleasePerformanceConfigurationINTEL( static_cast<VkDevice>( m_device ), static_cast<VkPerformanceConfigurationINTEL>( configuration ) ) );
20506 }
20507 #else
20508 // wrapper function for command vkReleasePerformanceConfigurationINTEL, see
20509 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleasePerformanceConfigurationINTEL.html
20510 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
20511 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::release( PerformanceConfigurationINTEL configuration,
20512 Dispatch const & d ) const
20513 {
20514 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
20515 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
20516 VULKAN_HPP_ASSERT( d.vkReleasePerformanceConfigurationINTEL && "Function <vkReleasePerformanceConfigurationINTEL> requires <VK_INTEL_performance_query>" );
20517 # endif
20518
20519 Result result = static_cast<Result>( d.vkReleasePerformanceConfigurationINTEL( m_device, static_cast<VkPerformanceConfigurationINTEL>( configuration ) ) );
20520 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::release" );
20521
20522 return detail::createResultValueType( result );
20523 }
20524 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
20525
20526 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
20527 // wrapper function for command vkQueueSetPerformanceConfigurationINTEL, see
20528 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSetPerformanceConfigurationINTEL.html
20529 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
20530 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Queue::setPerformanceConfigurationINTEL( PerformanceConfigurationINTEL configuration,
20531 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
20532 {
20533 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
20534 return static_cast<Result>(
20535 d.vkQueueSetPerformanceConfigurationINTEL( static_cast<VkQueue>( m_queue ), static_cast<VkPerformanceConfigurationINTEL>( configuration ) ) );
20536 }
20537 #else
20538 // wrapper function for command vkQueueSetPerformanceConfigurationINTEL, see
20539 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSetPerformanceConfigurationINTEL.html
20540 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
20541 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
20542 Queue::setPerformanceConfigurationINTEL( PerformanceConfigurationINTEL configuration, Dispatch const & d ) const
20543 {
20544 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
20545 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
20546 VULKAN_HPP_ASSERT( d.vkQueueSetPerformanceConfigurationINTEL &&
20547 "Function <vkQueueSetPerformanceConfigurationINTEL> requires <VK_INTEL_performance_query>" );
20548 # endif
20549
20550 Result result = static_cast<Result>( d.vkQueueSetPerformanceConfigurationINTEL( m_queue, static_cast<VkPerformanceConfigurationINTEL>( configuration ) ) );
20551 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::setPerformanceConfigurationINTEL" );
20552
20553 return detail::createResultValueType( result );
20554 }
20555 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
20556
20557 // wrapper function for command vkGetPerformanceParameterINTEL, see
20558 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPerformanceParameterINTEL.html
20559 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
20560 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getPerformanceParameterINTEL( PerformanceParameterTypeINTEL parameter,
20561 PerformanceValueINTEL * pValue,
20562 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
20563 {
20564 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
20565 return static_cast<Result>( d.vkGetPerformanceParameterINTEL(
20566 static_cast<VkDevice>( m_device ), static_cast<VkPerformanceParameterTypeINTEL>( parameter ), reinterpret_cast<VkPerformanceValueINTEL *>( pValue ) ) );
20567 }
20568
20569 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
20570 // wrapper function for command vkGetPerformanceParameterINTEL, see
20571 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPerformanceParameterINTEL.html
20572 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
20573 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<PerformanceValueINTEL>::type
20574 Device::getPerformanceParameterINTEL( PerformanceParameterTypeINTEL parameter, Dispatch const & d ) const
20575 {
20576 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
20577 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
20578 VULKAN_HPP_ASSERT( d.vkGetPerformanceParameterINTEL && "Function <vkGetPerformanceParameterINTEL> requires <VK_INTEL_performance_query>" );
20579 # endif
20580
20581 PerformanceValueINTEL value;
20582 Result result = static_cast<Result>( d.vkGetPerformanceParameterINTEL(
20583 m_device, static_cast<VkPerformanceParameterTypeINTEL>( parameter ), reinterpret_cast<VkPerformanceValueINTEL *>( &value ) ) );
20584 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPerformanceParameterINTEL" );
20585
20586 return detail::createResultValueType( result, std::move( value ) );
20587 }
20588 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
20589
20590 //=== VK_AMD_display_native_hdr ===
20591
20592 // wrapper function for command vkSetLocalDimmingAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetLocalDimmingAMD.html
20593 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
20594 VULKAN_HPP_INLINE void Device::setLocalDimmingAMD( SwapchainKHR swapChain, Bool32 localDimmingEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
20595 {
20596 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
20597 d.vkSetLocalDimmingAMD( static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( swapChain ), static_cast<VkBool32>( localDimmingEnable ) );
20598 }
20599
20600 #if defined( VK_USE_PLATFORM_FUCHSIA )
20601 //=== VK_FUCHSIA_imagepipe_surface ===
20602
20603 // wrapper function for command vkCreateImagePipeSurfaceFUCHSIA, see
20604 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImagePipeSurfaceFUCHSIA.html
20605 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
20606 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createImagePipeSurfaceFUCHSIA( const ImagePipeSurfaceCreateInfoFUCHSIA * pCreateInfo,
20607 const AllocationCallbacks * pAllocator,
20608 SurfaceKHR * pSurface,
20609 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
20610 {
20611 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
20612 return static_cast<Result>( d.vkCreateImagePipeSurfaceFUCHSIA( static_cast<VkInstance>( m_instance ),
20613 reinterpret_cast<const VkImagePipeSurfaceCreateInfoFUCHSIA *>( pCreateInfo ),
20614 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
20615 reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) );
20616 }
20617
20618 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
20619 // wrapper function for command vkCreateImagePipeSurfaceFUCHSIA, see
20620 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImagePipeSurfaceFUCHSIA.html
20621 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
20622 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<SurfaceKHR>::type Instance::createImagePipeSurfaceFUCHSIA(
20623 const ImagePipeSurfaceCreateInfoFUCHSIA & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
20624 {
20625 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
20626 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
20627 VULKAN_HPP_ASSERT( d.vkCreateImagePipeSurfaceFUCHSIA && "Function <vkCreateImagePipeSurfaceFUCHSIA> requires <VK_FUCHSIA_imagepipe_surface>" );
20628 # endif
20629
20630 SurfaceKHR surface;
20631 Result result = static_cast<Result>( d.vkCreateImagePipeSurfaceFUCHSIA( m_instance,
20632 reinterpret_cast<const VkImagePipeSurfaceCreateInfoFUCHSIA *>( &createInfo ),
20633 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
20634 reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
20635 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createImagePipeSurfaceFUCHSIA" );
20636
20637 return detail::createResultValueType( result, std::move( surface ) );
20638 }
20639
20640 # ifndef VULKAN_HPP_NO_SMART_HANDLE
20641 // wrapper function for command vkCreateImagePipeSurfaceFUCHSIA, see
20642 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImagePipeSurfaceFUCHSIA.html
20643 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
20644 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type Instance::createImagePipeSurfaceFUCHSIAUnique(
20645 const ImagePipeSurfaceCreateInfoFUCHSIA & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
20646 {
20647 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
20648 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
20649 VULKAN_HPP_ASSERT( d.vkCreateImagePipeSurfaceFUCHSIA && "Function <vkCreateImagePipeSurfaceFUCHSIA> requires <VK_FUCHSIA_imagepipe_surface>" );
20650 # endif
20651
20652 SurfaceKHR surface;
20653 Result result = static_cast<Result>( d.vkCreateImagePipeSurfaceFUCHSIA( m_instance,
20654 reinterpret_cast<const VkImagePipeSurfaceCreateInfoFUCHSIA *>( &createInfo ),
20655 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
20656 reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
20657 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createImagePipeSurfaceFUCHSIAUnique" );
20658
20659 return detail::createResultValueType( result,
20660 UniqueHandle<SurfaceKHR, Dispatch>( surface, detail::ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) );
20661 }
20662 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
20663 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
20664 #endif /*VK_USE_PLATFORM_FUCHSIA*/
20665
20666 #if defined( VK_USE_PLATFORM_METAL_EXT )
20667 //=== VK_EXT_metal_surface ===
20668
20669 // wrapper function for command vkCreateMetalSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMetalSurfaceEXT.html
20670 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
20671 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createMetalSurfaceEXT( const MetalSurfaceCreateInfoEXT * pCreateInfo,
20672 const AllocationCallbacks * pAllocator,
20673 SurfaceKHR * pSurface,
20674 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
20675 {
20676 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
20677 return static_cast<Result>( d.vkCreateMetalSurfaceEXT( static_cast<VkInstance>( m_instance ),
20678 reinterpret_cast<const VkMetalSurfaceCreateInfoEXT *>( pCreateInfo ),
20679 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
20680 reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) );
20681 }
20682
20683 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
20684 // wrapper function for command vkCreateMetalSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMetalSurfaceEXT.html
20685 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
20686 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<SurfaceKHR>::type
20687 Instance::createMetalSurfaceEXT( const MetalSurfaceCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
20688 {
20689 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
20690 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
20691 VULKAN_HPP_ASSERT( d.vkCreateMetalSurfaceEXT && "Function <vkCreateMetalSurfaceEXT> requires <VK_EXT_metal_surface>" );
20692 # endif
20693
20694 SurfaceKHR surface;
20695 Result result = static_cast<Result>( d.vkCreateMetalSurfaceEXT( m_instance,
20696 reinterpret_cast<const VkMetalSurfaceCreateInfoEXT *>( &createInfo ),
20697 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
20698 reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
20699 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createMetalSurfaceEXT" );
20700
20701 return detail::createResultValueType( result, std::move( surface ) );
20702 }
20703
20704 # ifndef VULKAN_HPP_NO_SMART_HANDLE
20705 // wrapper function for command vkCreateMetalSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMetalSurfaceEXT.html
20706 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
20707 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type Instance::createMetalSurfaceEXTUnique(
20708 const MetalSurfaceCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
20709 {
20710 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
20711 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
20712 VULKAN_HPP_ASSERT( d.vkCreateMetalSurfaceEXT && "Function <vkCreateMetalSurfaceEXT> requires <VK_EXT_metal_surface>" );
20713 # endif
20714
20715 SurfaceKHR surface;
20716 Result result = static_cast<Result>( d.vkCreateMetalSurfaceEXT( m_instance,
20717 reinterpret_cast<const VkMetalSurfaceCreateInfoEXT *>( &createInfo ),
20718 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
20719 reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
20720 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createMetalSurfaceEXTUnique" );
20721
20722 return detail::createResultValueType( result,
20723 UniqueHandle<SurfaceKHR, Dispatch>( surface, detail::ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) );
20724 }
20725 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
20726 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
20727 #endif /*VK_USE_PLATFORM_METAL_EXT*/
20728
20729 //=== VK_KHR_fragment_shading_rate ===
20730
20731 // wrapper function for command vkGetPhysicalDeviceFragmentShadingRatesKHR, see
20732 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFragmentShadingRatesKHR.html
20733 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
20734 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getFragmentShadingRatesKHR( uint32_t * pFragmentShadingRateCount,
20735 PhysicalDeviceFragmentShadingRateKHR * pFragmentShadingRates,
20736 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
20737 {
20738 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
20739 return static_cast<Result>(
20740 d.vkGetPhysicalDeviceFragmentShadingRatesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
20741 pFragmentShadingRateCount,
20742 reinterpret_cast<VkPhysicalDeviceFragmentShadingRateKHR *>( pFragmentShadingRates ) ) );
20743 }
20744
20745 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
20746 // wrapper function for command vkGetPhysicalDeviceFragmentShadingRatesKHR, see
20747 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFragmentShadingRatesKHR.html
20748 template <
20749 typename PhysicalDeviceFragmentShadingRateKHRAllocator,
20750 typename Dispatch,
20751 typename std::enable_if<std::is_same<typename PhysicalDeviceFragmentShadingRateKHRAllocator::value_type, PhysicalDeviceFragmentShadingRateKHR>::value,
20752 int>::type,
20753 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
20754 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
20755 typename ResultValueType<std::vector<PhysicalDeviceFragmentShadingRateKHR, PhysicalDeviceFragmentShadingRateKHRAllocator>>::type
20756 PhysicalDevice::getFragmentShadingRatesKHR( Dispatch const & d ) const
20757 {
20758 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
20759 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
20760 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceFragmentShadingRatesKHR &&
20761 "Function <vkGetPhysicalDeviceFragmentShadingRatesKHR> requires <VK_KHR_fragment_shading_rate>" );
20762 # endif
20763
20764 std::vector<PhysicalDeviceFragmentShadingRateKHR, PhysicalDeviceFragmentShadingRateKHRAllocator> fragmentShadingRates;
20765 uint32_t fragmentShadingRateCount;
20766 Result result;
20767 do
20768 {
20769 result = static_cast<Result>( d.vkGetPhysicalDeviceFragmentShadingRatesKHR( m_physicalDevice, &fragmentShadingRateCount, nullptr ) );
20770 if ( ( result == Result::eSuccess ) && fragmentShadingRateCount )
20771 {
20772 fragmentShadingRates.resize( fragmentShadingRateCount );
20773 result = static_cast<Result>( d.vkGetPhysicalDeviceFragmentShadingRatesKHR(
20774 m_physicalDevice, &fragmentShadingRateCount, reinterpret_cast<VkPhysicalDeviceFragmentShadingRateKHR *>( fragmentShadingRates.data() ) ) );
20775 }
20776 } while ( result == Result::eIncomplete );
20777 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getFragmentShadingRatesKHR" );
20778 VULKAN_HPP_ASSERT( fragmentShadingRateCount <= fragmentShadingRates.size() );
20779 if ( fragmentShadingRateCount < fragmentShadingRates.size() )
20780 {
20781 fragmentShadingRates.resize( fragmentShadingRateCount );
20782 }
20783 return detail::createResultValueType( result, std::move( fragmentShadingRates ) );
20784 }
20785
20786 // wrapper function for command vkGetPhysicalDeviceFragmentShadingRatesKHR, see
20787 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFragmentShadingRatesKHR.html
20788 template <
20789 typename PhysicalDeviceFragmentShadingRateKHRAllocator,
20790 typename Dispatch,
20791 typename std::enable_if<std::is_same<typename PhysicalDeviceFragmentShadingRateKHRAllocator::value_type, PhysicalDeviceFragmentShadingRateKHR>::value,
20792 int>::type,
20793 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
20794 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
20795 typename ResultValueType<std::vector<PhysicalDeviceFragmentShadingRateKHR, PhysicalDeviceFragmentShadingRateKHRAllocator>>::type
20796 PhysicalDevice::getFragmentShadingRatesKHR( PhysicalDeviceFragmentShadingRateKHRAllocator & physicalDeviceFragmentShadingRateKHRAllocator,
20797 Dispatch const & d ) const
20798 {
20799 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
20800 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
20801 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceFragmentShadingRatesKHR &&
20802 "Function <vkGetPhysicalDeviceFragmentShadingRatesKHR> requires <VK_KHR_fragment_shading_rate>" );
20803 # endif
20804
20805 std::vector<PhysicalDeviceFragmentShadingRateKHR, PhysicalDeviceFragmentShadingRateKHRAllocator> fragmentShadingRates(
20806 physicalDeviceFragmentShadingRateKHRAllocator );
20807 uint32_t fragmentShadingRateCount;
20808 Result result;
20809 do
20810 {
20811 result = static_cast<Result>( d.vkGetPhysicalDeviceFragmentShadingRatesKHR( m_physicalDevice, &fragmentShadingRateCount, nullptr ) );
20812 if ( ( result == Result::eSuccess ) && fragmentShadingRateCount )
20813 {
20814 fragmentShadingRates.resize( fragmentShadingRateCount );
20815 result = static_cast<Result>( d.vkGetPhysicalDeviceFragmentShadingRatesKHR(
20816 m_physicalDevice, &fragmentShadingRateCount, reinterpret_cast<VkPhysicalDeviceFragmentShadingRateKHR *>( fragmentShadingRates.data() ) ) );
20817 }
20818 } while ( result == Result::eIncomplete );
20819 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getFragmentShadingRatesKHR" );
20820 VULKAN_HPP_ASSERT( fragmentShadingRateCount <= fragmentShadingRates.size() );
20821 if ( fragmentShadingRateCount < fragmentShadingRates.size() )
20822 {
20823 fragmentShadingRates.resize( fragmentShadingRateCount );
20824 }
20825 return detail::createResultValueType( result, std::move( fragmentShadingRates ) );
20826 }
20827 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
20828
20829 // wrapper function for command vkCmdSetFragmentShadingRateKHR, see
20830 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFragmentShadingRateKHR.html
20831 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
20832 VULKAN_HPP_INLINE void CommandBuffer::setFragmentShadingRateKHR( const Extent2D * pFragmentSize,
20833 const FragmentShadingRateCombinerOpKHR combinerOps[2],
20834 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
20835 {
20836 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
20837 d.vkCmdSetFragmentShadingRateKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
20838 reinterpret_cast<const VkExtent2D *>( pFragmentSize ),
20839 reinterpret_cast<const VkFragmentShadingRateCombinerOpKHR *>( combinerOps ) );
20840 }
20841
20842 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
20843 // wrapper function for command vkCmdSetFragmentShadingRateKHR, see
20844 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFragmentShadingRateKHR.html
20845 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
20846 VULKAN_HPP_INLINE void CommandBuffer::setFragmentShadingRateKHR( const Extent2D & fragmentSize,
20847 const FragmentShadingRateCombinerOpKHR combinerOps[2],
20848 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
20849 {
20850 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
20851 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
20852 VULKAN_HPP_ASSERT( d.vkCmdSetFragmentShadingRateKHR && "Function <vkCmdSetFragmentShadingRateKHR> requires <VK_KHR_fragment_shading_rate>" );
20853 # endif
20854
20855 d.vkCmdSetFragmentShadingRateKHR(
20856 m_commandBuffer, reinterpret_cast<const VkExtent2D *>( &fragmentSize ), reinterpret_cast<const VkFragmentShadingRateCombinerOpKHR *>( combinerOps ) );
20857 }
20858 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
20859
20860 //=== VK_KHR_dynamic_rendering_local_read ===
20861
20862 // wrapper function for command vkCmdSetRenderingAttachmentLocationsKHR, see
20863 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingAttachmentLocationsKHR.html
20864 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
20865 VULKAN_HPP_INLINE void CommandBuffer::setRenderingAttachmentLocationsKHR( const RenderingAttachmentLocationInfo * pLocationInfo,
20866 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
20867 {
20868 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
20869 d.vkCmdSetRenderingAttachmentLocationsKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
20870 reinterpret_cast<const VkRenderingAttachmentLocationInfo *>( pLocationInfo ) );
20871 }
20872
20873 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
20874 // wrapper function for command vkCmdSetRenderingAttachmentLocationsKHR, see
20875 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingAttachmentLocationsKHR.html
20876 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
20877 VULKAN_HPP_INLINE void CommandBuffer::setRenderingAttachmentLocationsKHR( const RenderingAttachmentLocationInfo & locationInfo,
20878 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
20879 {
20880 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
20881 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
20882 VULKAN_HPP_ASSERT( d.vkCmdSetRenderingAttachmentLocationsKHR &&
20883 "Function <vkCmdSetRenderingAttachmentLocationsKHR> requires <VK_KHR_dynamic_rendering_local_read> or <VK_VERSION_1_4>" );
20884 # endif
20885
20886 d.vkCmdSetRenderingAttachmentLocationsKHR( m_commandBuffer, reinterpret_cast<const VkRenderingAttachmentLocationInfo *>( &locationInfo ) );
20887 }
20888 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
20889
20890 // wrapper function for command vkCmdSetRenderingInputAttachmentIndicesKHR, see
20891 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingInputAttachmentIndicesKHR.html
20892 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
20893 VULKAN_HPP_INLINE void CommandBuffer::setRenderingInputAttachmentIndicesKHR( const RenderingInputAttachmentIndexInfo * pInputAttachmentIndexInfo,
20894 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
20895 {
20896 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
20897 d.vkCmdSetRenderingInputAttachmentIndicesKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
20898 reinterpret_cast<const VkRenderingInputAttachmentIndexInfo *>( pInputAttachmentIndexInfo ) );
20899 }
20900
20901 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
20902 // wrapper function for command vkCmdSetRenderingInputAttachmentIndicesKHR, see
20903 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingInputAttachmentIndicesKHR.html
20904 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
20905 VULKAN_HPP_INLINE void CommandBuffer::setRenderingInputAttachmentIndicesKHR( const RenderingInputAttachmentIndexInfo & inputAttachmentIndexInfo,
20906 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
20907 {
20908 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
20909 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
20910 VULKAN_HPP_ASSERT( d.vkCmdSetRenderingInputAttachmentIndicesKHR &&
20911 "Function <vkCmdSetRenderingInputAttachmentIndicesKHR> requires <VK_KHR_dynamic_rendering_local_read> or <VK_VERSION_1_4>" );
20912 # endif
20913
20914 d.vkCmdSetRenderingInputAttachmentIndicesKHR( m_commandBuffer, reinterpret_cast<const VkRenderingInputAttachmentIndexInfo *>( &inputAttachmentIndexInfo ) );
20915 }
20916 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
20917
20918 //=== VK_EXT_buffer_device_address ===
20919
20920 // wrapper function for command vkGetBufferDeviceAddressEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferDeviceAddressEXT.html
20921 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
20922 VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddressEXT( const BufferDeviceAddressInfo * pInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
20923 {
20924 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
20925 return static_cast<DeviceAddress>(
20926 d.vkGetBufferDeviceAddressEXT( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkBufferDeviceAddressInfo *>( pInfo ) ) );
20927 }
20928
20929 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
20930 // wrapper function for command vkGetBufferDeviceAddressEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferDeviceAddressEXT.html
20931 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
20932 VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddressEXT( const BufferDeviceAddressInfo & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
20933 {
20934 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
20935 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
20936 VULKAN_HPP_ASSERT( d.vkGetBufferDeviceAddressEXT &&
20937 "Function <vkGetBufferDeviceAddressEXT> requires <VK_EXT_buffer_device_address> or <VK_KHR_buffer_device_address> or <VK_VERSION_1_2>" );
20938 # endif
20939
20940 VkDeviceAddress result = d.vkGetBufferDeviceAddressEXT( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo *>( &info ) );
20941
20942 return static_cast<DeviceAddress>( result );
20943 }
20944 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
20945
20946 //=== VK_EXT_tooling_info ===
20947
20948 // wrapper function for command vkGetPhysicalDeviceToolPropertiesEXT, see
20949 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceToolPropertiesEXT.html
20950 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
20951 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getToolPropertiesEXT( uint32_t * pToolCount,
20952 PhysicalDeviceToolProperties * pToolProperties,
20953 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
20954 {
20955 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
20956 return static_cast<Result>( d.vkGetPhysicalDeviceToolPropertiesEXT(
20957 static_cast<VkPhysicalDevice>( m_physicalDevice ), pToolCount, reinterpret_cast<VkPhysicalDeviceToolProperties *>( pToolProperties ) ) );
20958 }
20959
20960 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
20961 // wrapper function for command vkGetPhysicalDeviceToolPropertiesEXT, see
20962 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceToolPropertiesEXT.html
20963 template <typename PhysicalDeviceToolPropertiesAllocator,
20964 typename Dispatch,
20965 typename std::enable_if<std::is_same<typename PhysicalDeviceToolPropertiesAllocator::value_type, PhysicalDeviceToolProperties>::value, int>::type,
20966 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
20967 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator>>::type
20968 PhysicalDevice::getToolPropertiesEXT( Dispatch const & d ) const
20969 {
20970 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
20971 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
20972 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceToolPropertiesEXT &&
20973 "Function <vkGetPhysicalDeviceToolPropertiesEXT> requires <VK_EXT_tooling_info> or <VK_VERSION_1_3>" );
20974 # endif
20975
20976 std::vector<PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator> toolProperties;
20977 uint32_t toolCount;
20978 Result result;
20979 do
20980 {
20981 result = static_cast<Result>( d.vkGetPhysicalDeviceToolPropertiesEXT( m_physicalDevice, &toolCount, nullptr ) );
20982 if ( ( result == Result::eSuccess ) && toolCount )
20983 {
20984 toolProperties.resize( toolCount );
20985 result = static_cast<Result>(
20986 d.vkGetPhysicalDeviceToolPropertiesEXT( m_physicalDevice, &toolCount, reinterpret_cast<VkPhysicalDeviceToolProperties *>( toolProperties.data() ) ) );
20987 }
20988 } while ( result == Result::eIncomplete );
20989 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getToolPropertiesEXT" );
20990 VULKAN_HPP_ASSERT( toolCount <= toolProperties.size() );
20991 if ( toolCount < toolProperties.size() )
20992 {
20993 toolProperties.resize( toolCount );
20994 }
20995 return detail::createResultValueType( result, std::move( toolProperties ) );
20996 }
20997
20998 // wrapper function for command vkGetPhysicalDeviceToolPropertiesEXT, see
20999 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceToolPropertiesEXT.html
21000 template <typename PhysicalDeviceToolPropertiesAllocator,
21001 typename Dispatch,
21002 typename std::enable_if<std::is_same<typename PhysicalDeviceToolPropertiesAllocator::value_type, PhysicalDeviceToolProperties>::value, int>::type,
21003 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
21004 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator>>::type
21005 PhysicalDevice::getToolPropertiesEXT( PhysicalDeviceToolPropertiesAllocator & physicalDeviceToolPropertiesAllocator, Dispatch const & d ) const
21006 {
21007 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
21008 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
21009 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceToolPropertiesEXT &&
21010 "Function <vkGetPhysicalDeviceToolPropertiesEXT> requires <VK_EXT_tooling_info> or <VK_VERSION_1_3>" );
21011 # endif
21012
21013 std::vector<PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator> toolProperties( physicalDeviceToolPropertiesAllocator );
21014 uint32_t toolCount;
21015 Result result;
21016 do
21017 {
21018 result = static_cast<Result>( d.vkGetPhysicalDeviceToolPropertiesEXT( m_physicalDevice, &toolCount, nullptr ) );
21019 if ( ( result == Result::eSuccess ) && toolCount )
21020 {
21021 toolProperties.resize( toolCount );
21022 result = static_cast<Result>(
21023 d.vkGetPhysicalDeviceToolPropertiesEXT( m_physicalDevice, &toolCount, reinterpret_cast<VkPhysicalDeviceToolProperties *>( toolProperties.data() ) ) );
21024 }
21025 } while ( result == Result::eIncomplete );
21026 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getToolPropertiesEXT" );
21027 VULKAN_HPP_ASSERT( toolCount <= toolProperties.size() );
21028 if ( toolCount < toolProperties.size() )
21029 {
21030 toolProperties.resize( toolCount );
21031 }
21032 return detail::createResultValueType( result, std::move( toolProperties ) );
21033 }
21034 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
21035
21036 //=== VK_KHR_present_wait ===
21037
21038 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
21039 // wrapper function for command vkWaitForPresentKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitForPresentKHR.html
21040 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
21041 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
21042 Device::waitForPresentKHR( SwapchainKHR swapchain, uint64_t presentId, uint64_t timeout, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
21043 {
21044 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
21045 return static_cast<Result>( d.vkWaitForPresentKHR( static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( swapchain ), presentId, timeout ) );
21046 }
21047 #else
21048 // wrapper function for command vkWaitForPresentKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitForPresentKHR.html
21049 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
21050 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
21051 Device::waitForPresentKHR( SwapchainKHR swapchain, uint64_t presentId, uint64_t timeout, Dispatch const & d ) const
21052 {
21053 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
21054 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
21055 VULKAN_HPP_ASSERT( d.vkWaitForPresentKHR && "Function <vkWaitForPresentKHR> requires <VK_KHR_present_wait>" );
21056 # endif
21057
21058 Result result = static_cast<Result>( d.vkWaitForPresentKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), presentId, timeout ) );
21059
21060 # if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS )
21061 detail::resultCheck( result,
21062 VULKAN_HPP_NAMESPACE_STRING "::Device::waitForPresentKHR",
21063 { Result::eSuccess, Result::eTimeout, Result::eSuboptimalKHR, Result::eErrorOutOfDateKHR } );
21064 # else
21065 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::waitForPresentKHR", { Result::eSuccess, Result::eTimeout, Result::eSuboptimalKHR } );
21066 # endif
21067
21068 return static_cast<Result>( result );
21069 }
21070 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
21071
21072 //=== VK_NV_cooperative_matrix ===
21073
21074 // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixPropertiesNV, see
21075 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixPropertiesNV.html
21076 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
21077 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getCooperativeMatrixPropertiesNV( uint32_t * pPropertyCount,
21078 CooperativeMatrixPropertiesNV * pProperties,
21079 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
21080 {
21081 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
21082 return static_cast<Result>( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(
21083 static_cast<VkPhysicalDevice>( m_physicalDevice ), pPropertyCount, reinterpret_cast<VkCooperativeMatrixPropertiesNV *>( pProperties ) ) );
21084 }
21085
21086 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
21087 // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixPropertiesNV, see
21088 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixPropertiesNV.html
21089 template <typename CooperativeMatrixPropertiesNVAllocator,
21090 typename Dispatch,
21091 typename std::enable_if<std::is_same<typename CooperativeMatrixPropertiesNVAllocator::value_type, CooperativeMatrixPropertiesNV>::value, int>::type,
21092 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
21093 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<CooperativeMatrixPropertiesNV, CooperativeMatrixPropertiesNVAllocator>>::type
21094 PhysicalDevice::getCooperativeMatrixPropertiesNV( Dispatch const & d ) const
21095 {
21096 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
21097 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
21098 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV &&
21099 "Function <vkGetPhysicalDeviceCooperativeMatrixPropertiesNV> requires <VK_NV_cooperative_matrix>" );
21100 # endif
21101
21102 std::vector<CooperativeMatrixPropertiesNV, CooperativeMatrixPropertiesNVAllocator> properties;
21103 uint32_t propertyCount;
21104 Result result;
21105 do
21106 {
21107 result = static_cast<Result>( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( m_physicalDevice, &propertyCount, nullptr ) );
21108 if ( ( result == Result::eSuccess ) && propertyCount )
21109 {
21110 properties.resize( propertyCount );
21111 result = static_cast<Result>( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(
21112 m_physicalDevice, &propertyCount, reinterpret_cast<VkCooperativeMatrixPropertiesNV *>( properties.data() ) ) );
21113 }
21114 } while ( result == Result::eIncomplete );
21115 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCooperativeMatrixPropertiesNV" );
21116 VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
21117 if ( propertyCount < properties.size() )
21118 {
21119 properties.resize( propertyCount );
21120 }
21121 return detail::createResultValueType( result, std::move( properties ) );
21122 }
21123
21124 // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixPropertiesNV, see
21125 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixPropertiesNV.html
21126 template <typename CooperativeMatrixPropertiesNVAllocator,
21127 typename Dispatch,
21128 typename std::enable_if<std::is_same<typename CooperativeMatrixPropertiesNVAllocator::value_type, CooperativeMatrixPropertiesNV>::value, int>::type,
21129 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
21130 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<CooperativeMatrixPropertiesNV, CooperativeMatrixPropertiesNVAllocator>>::type
21131 PhysicalDevice::getCooperativeMatrixPropertiesNV( CooperativeMatrixPropertiesNVAllocator & cooperativeMatrixPropertiesNVAllocator,
21132 Dispatch const & d ) const
21133 {
21134 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
21135 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
21136 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV &&
21137 "Function <vkGetPhysicalDeviceCooperativeMatrixPropertiesNV> requires <VK_NV_cooperative_matrix>" );
21138 # endif
21139
21140 std::vector<CooperativeMatrixPropertiesNV, CooperativeMatrixPropertiesNVAllocator> properties( cooperativeMatrixPropertiesNVAllocator );
21141 uint32_t propertyCount;
21142 Result result;
21143 do
21144 {
21145 result = static_cast<Result>( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( m_physicalDevice, &propertyCount, nullptr ) );
21146 if ( ( result == Result::eSuccess ) && propertyCount )
21147 {
21148 properties.resize( propertyCount );
21149 result = static_cast<Result>( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(
21150 m_physicalDevice, &propertyCount, reinterpret_cast<VkCooperativeMatrixPropertiesNV *>( properties.data() ) ) );
21151 }
21152 } while ( result == Result::eIncomplete );
21153 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCooperativeMatrixPropertiesNV" );
21154 VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
21155 if ( propertyCount < properties.size() )
21156 {
21157 properties.resize( propertyCount );
21158 }
21159 return detail::createResultValueType( result, std::move( properties ) );
21160 }
21161 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
21162
21163 //=== VK_NV_coverage_reduction_mode ===
21164
21165 // wrapper function for command vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV, see
21166 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV.html
21167 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
21168 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV(
21169 uint32_t * pCombinationCount, FramebufferMixedSamplesCombinationNV * pCombinations, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
21170 {
21171 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
21172 return static_cast<Result>( d.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(
21173 static_cast<VkPhysicalDevice>( m_physicalDevice ), pCombinationCount, reinterpret_cast<VkFramebufferMixedSamplesCombinationNV *>( pCombinations ) ) );
21174 }
21175
21176 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
21177 // wrapper function for command vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV, see
21178 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV.html
21179 template <
21180 typename FramebufferMixedSamplesCombinationNVAllocator,
21181 typename Dispatch,
21182 typename std::enable_if<std::is_same<typename FramebufferMixedSamplesCombinationNVAllocator::value_type, FramebufferMixedSamplesCombinationNV>::value,
21183 int>::type,
21184 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
21185 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
21186 typename ResultValueType<std::vector<FramebufferMixedSamplesCombinationNV, FramebufferMixedSamplesCombinationNVAllocator>>::type
21187 PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV( Dispatch const & d ) const
21188 {
21189 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
21190 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
21191 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV &&
21192 "Function <vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV> requires <VK_NV_coverage_reduction_mode>" );
21193 # endif
21194
21195 std::vector<FramebufferMixedSamplesCombinationNV, FramebufferMixedSamplesCombinationNVAllocator> combinations;
21196 uint32_t combinationCount;
21197 Result result;
21198 do
21199 {
21200 result = static_cast<Result>( d.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( m_physicalDevice, &combinationCount, nullptr ) );
21201 if ( ( result == Result::eSuccess ) && combinationCount )
21202 {
21203 combinations.resize( combinationCount );
21204 result = static_cast<Result>( d.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(
21205 m_physicalDevice, &combinationCount, reinterpret_cast<VkFramebufferMixedSamplesCombinationNV *>( combinations.data() ) ) );
21206 }
21207 } while ( result == Result::eIncomplete );
21208 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV" );
21209 VULKAN_HPP_ASSERT( combinationCount <= combinations.size() );
21210 if ( combinationCount < combinations.size() )
21211 {
21212 combinations.resize( combinationCount );
21213 }
21214 return detail::createResultValueType( result, std::move( combinations ) );
21215 }
21216
21217 // wrapper function for command vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV, see
21218 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV.html
21219 template <
21220 typename FramebufferMixedSamplesCombinationNVAllocator,
21221 typename Dispatch,
21222 typename std::enable_if<std::is_same<typename FramebufferMixedSamplesCombinationNVAllocator::value_type, FramebufferMixedSamplesCombinationNV>::value,
21223 int>::type,
21224 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
21225 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
21226 typename ResultValueType<std::vector<FramebufferMixedSamplesCombinationNV, FramebufferMixedSamplesCombinationNVAllocator>>::type
21227 PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV(
21228 FramebufferMixedSamplesCombinationNVAllocator & framebufferMixedSamplesCombinationNVAllocator, Dispatch const & d ) const
21229 {
21230 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
21231 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
21232 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV &&
21233 "Function <vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV> requires <VK_NV_coverage_reduction_mode>" );
21234 # endif
21235
21236 std::vector<FramebufferMixedSamplesCombinationNV, FramebufferMixedSamplesCombinationNVAllocator> combinations(
21237 framebufferMixedSamplesCombinationNVAllocator );
21238 uint32_t combinationCount;
21239 Result result;
21240 do
21241 {
21242 result = static_cast<Result>( d.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( m_physicalDevice, &combinationCount, nullptr ) );
21243 if ( ( result == Result::eSuccess ) && combinationCount )
21244 {
21245 combinations.resize( combinationCount );
21246 result = static_cast<Result>( d.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(
21247 m_physicalDevice, &combinationCount, reinterpret_cast<VkFramebufferMixedSamplesCombinationNV *>( combinations.data() ) ) );
21248 }
21249 } while ( result == Result::eIncomplete );
21250 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV" );
21251 VULKAN_HPP_ASSERT( combinationCount <= combinations.size() );
21252 if ( combinationCount < combinations.size() )
21253 {
21254 combinations.resize( combinationCount );
21255 }
21256 return detail::createResultValueType( result, std::move( combinations ) );
21257 }
21258 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
21259
21260 #if defined( VK_USE_PLATFORM_WIN32_KHR )
21261 //=== VK_EXT_full_screen_exclusive ===
21262
21263 // wrapper function for command vkGetPhysicalDeviceSurfacePresentModes2EXT, see
21264 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfacePresentModes2EXT.html
21265 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
21266 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
21267 uint32_t * pPresentModeCount,
21268 PresentModeKHR * pPresentModes,
21269 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
21270 {
21271 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
21272 return static_cast<Result>( d.vkGetPhysicalDeviceSurfacePresentModes2EXT( static_cast<VkPhysicalDevice>( m_physicalDevice ),
21273 reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( pSurfaceInfo ),
21274 pPresentModeCount,
21275 reinterpret_cast<VkPresentModeKHR *>( pPresentModes ) ) );
21276 }
21277
21278 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
21279 // wrapper function for command vkGetPhysicalDeviceSurfacePresentModes2EXT, see
21280 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfacePresentModes2EXT.html
21281 template <typename PresentModeKHRAllocator,
21282 typename Dispatch,
21283 typename std::enable_if<std::is_same<typename PresentModeKHRAllocator::value_type, PresentModeKHR>::value, int>::type,
21284 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
21285 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<PresentModeKHR, PresentModeKHRAllocator>>::type
21286 PhysicalDevice::getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d ) const
21287 {
21288 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
21289 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
21290 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfacePresentModes2EXT &&
21291 "Function <vkGetPhysicalDeviceSurfacePresentModes2EXT> requires <VK_EXT_full_screen_exclusive>" );
21292 # endif
21293
21294 std::vector<PresentModeKHR, PresentModeKHRAllocator> presentModes;
21295 uint32_t presentModeCount;
21296 Result result;
21297 do
21298 {
21299 result = static_cast<Result>( d.vkGetPhysicalDeviceSurfacePresentModes2EXT(
21300 m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ), &presentModeCount, nullptr ) );
21301 if ( ( result == Result::eSuccess ) && presentModeCount )
21302 {
21303 presentModes.resize( presentModeCount );
21304 result = static_cast<Result>( d.vkGetPhysicalDeviceSurfacePresentModes2EXT( m_physicalDevice,
21305 reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ),
21306 &presentModeCount,
21307 reinterpret_cast<VkPresentModeKHR *>( presentModes.data() ) ) );
21308 }
21309 } while ( result == Result::eIncomplete );
21310 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfacePresentModes2EXT" );
21311 VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() );
21312 if ( presentModeCount < presentModes.size() )
21313 {
21314 presentModes.resize( presentModeCount );
21315 }
21316 return detail::createResultValueType( result, std::move( presentModes ) );
21317 }
21318
21319 // wrapper function for command vkGetPhysicalDeviceSurfacePresentModes2EXT, see
21320 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfacePresentModes2EXT.html
21321 template <typename PresentModeKHRAllocator,
21322 typename Dispatch,
21323 typename std::enable_if<std::is_same<typename PresentModeKHRAllocator::value_type, PresentModeKHR>::value, int>::type,
21324 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
21325 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<PresentModeKHR, PresentModeKHRAllocator>>::type
21326 PhysicalDevice::getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
21327 PresentModeKHRAllocator & presentModeKHRAllocator,
21328 Dispatch const & d ) const
21329 {
21330 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
21331 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
21332 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfacePresentModes2EXT &&
21333 "Function <vkGetPhysicalDeviceSurfacePresentModes2EXT> requires <VK_EXT_full_screen_exclusive>" );
21334 # endif
21335
21336 std::vector<PresentModeKHR, PresentModeKHRAllocator> presentModes( presentModeKHRAllocator );
21337 uint32_t presentModeCount;
21338 Result result;
21339 do
21340 {
21341 result = static_cast<Result>( d.vkGetPhysicalDeviceSurfacePresentModes2EXT(
21342 m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ), &presentModeCount, nullptr ) );
21343 if ( ( result == Result::eSuccess ) && presentModeCount )
21344 {
21345 presentModes.resize( presentModeCount );
21346 result = static_cast<Result>( d.vkGetPhysicalDeviceSurfacePresentModes2EXT( m_physicalDevice,
21347 reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ),
21348 &presentModeCount,
21349 reinterpret_cast<VkPresentModeKHR *>( presentModes.data() ) ) );
21350 }
21351 } while ( result == Result::eIncomplete );
21352 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfacePresentModes2EXT" );
21353 VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() );
21354 if ( presentModeCount < presentModes.size() )
21355 {
21356 presentModes.resize( presentModeCount );
21357 }
21358 return detail::createResultValueType( result, std::move( presentModes ) );
21359 }
21360 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
21361
21362 # ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
21363 // wrapper function for command vkAcquireFullScreenExclusiveModeEXT, see
21364 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireFullScreenExclusiveModeEXT.html
21365 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
21366 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::acquireFullScreenExclusiveModeEXT( SwapchainKHR swapchain,
21367 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
21368 {
21369 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
21370 return static_cast<Result>( d.vkAcquireFullScreenExclusiveModeEXT( static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( swapchain ) ) );
21371 }
21372 # else
21373 // wrapper function for command vkAcquireFullScreenExclusiveModeEXT, see
21374 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireFullScreenExclusiveModeEXT.html
21375 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
21376 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
21377 Device::acquireFullScreenExclusiveModeEXT( SwapchainKHR swapchain, Dispatch const & d ) const
21378 {
21379 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
21380 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
21381 VULKAN_HPP_ASSERT( d.vkAcquireFullScreenExclusiveModeEXT && "Function <vkAcquireFullScreenExclusiveModeEXT> requires <VK_EXT_full_screen_exclusive>" );
21382 # endif
21383
21384 Result result = static_cast<Result>( d.vkAcquireFullScreenExclusiveModeEXT( m_device, static_cast<VkSwapchainKHR>( swapchain ) ) );
21385 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::acquireFullScreenExclusiveModeEXT" );
21386
21387 return detail::createResultValueType( result );
21388 }
21389 # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
21390
21391 # ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
21392 // wrapper function for command vkReleaseFullScreenExclusiveModeEXT, see
21393 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseFullScreenExclusiveModeEXT.html
21394 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
21395 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::releaseFullScreenExclusiveModeEXT( SwapchainKHR swapchain,
21396 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
21397 {
21398 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
21399 return static_cast<Result>( d.vkReleaseFullScreenExclusiveModeEXT( static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( swapchain ) ) );
21400 }
21401 # else
21402 // wrapper function for command vkReleaseFullScreenExclusiveModeEXT, see
21403 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseFullScreenExclusiveModeEXT.html
21404 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
21405 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
21406 Device::releaseFullScreenExclusiveModeEXT( SwapchainKHR swapchain, Dispatch const & d ) const
21407 {
21408 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
21409 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
21410 VULKAN_HPP_ASSERT( d.vkReleaseFullScreenExclusiveModeEXT && "Function <vkReleaseFullScreenExclusiveModeEXT> requires <VK_EXT_full_screen_exclusive>" );
21411 # endif
21412
21413 Result result = static_cast<Result>( d.vkReleaseFullScreenExclusiveModeEXT( m_device, static_cast<VkSwapchainKHR>( swapchain ) ) );
21414 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::releaseFullScreenExclusiveModeEXT" );
21415
21416 return detail::createResultValueType( result );
21417 }
21418 # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
21419
21420 // wrapper function for command vkGetDeviceGroupSurfacePresentModes2EXT, see
21421 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupSurfacePresentModes2EXT.html
21422 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
21423 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getGroupSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
21424 DeviceGroupPresentModeFlagsKHR * pModes,
21425 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
21426 {
21427 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
21428 return static_cast<Result>( d.vkGetDeviceGroupSurfacePresentModes2EXT( static_cast<VkDevice>( m_device ),
21429 reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( pSurfaceInfo ),
21430 reinterpret_cast<VkDeviceGroupPresentModeFlagsKHR *>( pModes ) ) );
21431 }
21432
21433 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
21434 // wrapper function for command vkGetDeviceGroupSurfacePresentModes2EXT, see
21435 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupSurfacePresentModes2EXT.html
21436 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
21437 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<DeviceGroupPresentModeFlagsKHR>::type
21438 Device::getGroupSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d ) const
21439 {
21440 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
21441 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
21442 VULKAN_HPP_ASSERT( d.vkGetDeviceGroupSurfacePresentModes2EXT &&
21443 "Function <vkGetDeviceGroupSurfacePresentModes2EXT> requires <VK_EXT_full_screen_exclusive>" );
21444 # endif
21445
21446 DeviceGroupPresentModeFlagsKHR modes;
21447 Result result = static_cast<Result>( d.vkGetDeviceGroupSurfacePresentModes2EXT(
21448 m_device, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ), reinterpret_cast<VkDeviceGroupPresentModeFlagsKHR *>( &modes ) ) );
21449 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getGroupSurfacePresentModes2EXT" );
21450
21451 return detail::createResultValueType( result, std::move( modes ) );
21452 }
21453 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
21454 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
21455
21456 //=== VK_EXT_headless_surface ===
21457
21458 // wrapper function for command vkCreateHeadlessSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateHeadlessSurfaceEXT.html
21459 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
21460 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createHeadlessSurfaceEXT( const HeadlessSurfaceCreateInfoEXT * pCreateInfo,
21461 const AllocationCallbacks * pAllocator,
21462 SurfaceKHR * pSurface,
21463 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
21464 {
21465 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
21466 return static_cast<Result>( d.vkCreateHeadlessSurfaceEXT( static_cast<VkInstance>( m_instance ),
21467 reinterpret_cast<const VkHeadlessSurfaceCreateInfoEXT *>( pCreateInfo ),
21468 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
21469 reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) );
21470 }
21471
21472 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
21473 // wrapper function for command vkCreateHeadlessSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateHeadlessSurfaceEXT.html
21474 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
21475 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<SurfaceKHR>::type Instance::createHeadlessSurfaceEXT(
21476 const HeadlessSurfaceCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
21477 {
21478 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
21479 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
21480 VULKAN_HPP_ASSERT( d.vkCreateHeadlessSurfaceEXT && "Function <vkCreateHeadlessSurfaceEXT> requires <VK_EXT_headless_surface>" );
21481 # endif
21482
21483 SurfaceKHR surface;
21484 Result result = static_cast<Result>( d.vkCreateHeadlessSurfaceEXT( m_instance,
21485 reinterpret_cast<const VkHeadlessSurfaceCreateInfoEXT *>( &createInfo ),
21486 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
21487 reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
21488 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createHeadlessSurfaceEXT" );
21489
21490 return detail::createResultValueType( result, std::move( surface ) );
21491 }
21492
21493 # ifndef VULKAN_HPP_NO_SMART_HANDLE
21494 // wrapper function for command vkCreateHeadlessSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateHeadlessSurfaceEXT.html
21495 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
21496 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type Instance::createHeadlessSurfaceEXTUnique(
21497 const HeadlessSurfaceCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
21498 {
21499 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
21500 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
21501 VULKAN_HPP_ASSERT( d.vkCreateHeadlessSurfaceEXT && "Function <vkCreateHeadlessSurfaceEXT> requires <VK_EXT_headless_surface>" );
21502 # endif
21503
21504 SurfaceKHR surface;
21505 Result result = static_cast<Result>( d.vkCreateHeadlessSurfaceEXT( m_instance,
21506 reinterpret_cast<const VkHeadlessSurfaceCreateInfoEXT *>( &createInfo ),
21507 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
21508 reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
21509 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createHeadlessSurfaceEXTUnique" );
21510
21511 return detail::createResultValueType( result,
21512 UniqueHandle<SurfaceKHR, Dispatch>( surface, detail::ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) );
21513 }
21514 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
21515 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
21516
21517 //=== VK_KHR_buffer_device_address ===
21518
21519 // wrapper function for command vkGetBufferDeviceAddressKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferDeviceAddressKHR.html
21520 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
21521 VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddressKHR( const BufferDeviceAddressInfo * pInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
21522 {
21523 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
21524 return static_cast<DeviceAddress>(
21525 d.vkGetBufferDeviceAddressKHR( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkBufferDeviceAddressInfo *>( pInfo ) ) );
21526 }
21527
21528 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
21529 // wrapper function for command vkGetBufferDeviceAddressKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferDeviceAddressKHR.html
21530 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
21531 VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddressKHR( const BufferDeviceAddressInfo & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
21532 {
21533 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
21534 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
21535 VULKAN_HPP_ASSERT( d.vkGetBufferDeviceAddressKHR &&
21536 "Function <vkGetBufferDeviceAddressKHR> requires <VK_EXT_buffer_device_address> or <VK_KHR_buffer_device_address> or <VK_VERSION_1_2>" );
21537 # endif
21538
21539 VkDeviceAddress result = d.vkGetBufferDeviceAddressKHR( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo *>( &info ) );
21540
21541 return static_cast<DeviceAddress>( result );
21542 }
21543 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
21544
21545 // wrapper function for command vkGetBufferOpaqueCaptureAddressKHR, see
21546 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferOpaqueCaptureAddressKHR.html
21547 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
21548 VULKAN_HPP_INLINE uint64_t Device::getBufferOpaqueCaptureAddressKHR( const BufferDeviceAddressInfo * pInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
21549 {
21550 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
21551 return d.vkGetBufferOpaqueCaptureAddressKHR( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkBufferDeviceAddressInfo *>( pInfo ) );
21552 }
21553
21554 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
21555 // wrapper function for command vkGetBufferOpaqueCaptureAddressKHR, see
21556 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferOpaqueCaptureAddressKHR.html
21557 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
21558 VULKAN_HPP_INLINE uint64_t Device::getBufferOpaqueCaptureAddressKHR( const BufferDeviceAddressInfo & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
21559 {
21560 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
21561 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
21562 VULKAN_HPP_ASSERT( d.vkGetBufferOpaqueCaptureAddressKHR &&
21563 "Function <vkGetBufferOpaqueCaptureAddressKHR> requires <VK_KHR_buffer_device_address> or <VK_VERSION_1_2>" );
21564 # endif
21565
21566 uint64_t result = d.vkGetBufferOpaqueCaptureAddressKHR( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo *>( &info ) );
21567
21568 return result;
21569 }
21570 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
21571
21572 // wrapper function for command vkGetDeviceMemoryOpaqueCaptureAddressKHR, see
21573 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMemoryOpaqueCaptureAddressKHR.html
21574 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
21575 VULKAN_HPP_INLINE uint64_t Device::getMemoryOpaqueCaptureAddressKHR( const DeviceMemoryOpaqueCaptureAddressInfo * pInfo,
21576 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
21577 {
21578 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
21579 return d.vkGetDeviceMemoryOpaqueCaptureAddressKHR( static_cast<VkDevice>( m_device ),
21580 reinterpret_cast<const VkDeviceMemoryOpaqueCaptureAddressInfo *>( pInfo ) );
21581 }
21582
21583 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
21584 // wrapper function for command vkGetDeviceMemoryOpaqueCaptureAddressKHR, see
21585 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMemoryOpaqueCaptureAddressKHR.html
21586 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
21587 VULKAN_HPP_INLINE uint64_t Device::getMemoryOpaqueCaptureAddressKHR( const DeviceMemoryOpaqueCaptureAddressInfo & info,
21588 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
21589 {
21590 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
21591 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
21592 VULKAN_HPP_ASSERT( d.vkGetDeviceMemoryOpaqueCaptureAddressKHR &&
21593 "Function <vkGetDeviceMemoryOpaqueCaptureAddressKHR> requires <VK_KHR_buffer_device_address> or <VK_VERSION_1_2>" );
21594 # endif
21595
21596 uint64_t result = d.vkGetDeviceMemoryOpaqueCaptureAddressKHR( m_device, reinterpret_cast<const VkDeviceMemoryOpaqueCaptureAddressInfo *>( &info ) );
21597
21598 return result;
21599 }
21600 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
21601
21602 //=== VK_EXT_line_rasterization ===
21603
21604 // wrapper function for command vkCmdSetLineStippleEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineStippleEXT.html
21605 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
21606 VULKAN_HPP_INLINE void
21607 CommandBuffer::setLineStippleEXT( uint32_t lineStippleFactor, uint16_t lineStipplePattern, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
21608 {
21609 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
21610 d.vkCmdSetLineStippleEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), lineStippleFactor, lineStipplePattern );
21611 }
21612
21613 //=== VK_EXT_host_query_reset ===
21614
21615 // wrapper function for command vkResetQueryPoolEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetQueryPoolEXT.html
21616 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
21617 VULKAN_HPP_INLINE void
21618 Device::resetQueryPoolEXT( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
21619 {
21620 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
21621 d.vkResetQueryPoolEXT( static_cast<VkDevice>( m_device ), static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount );
21622 }
21623
21624 //=== VK_EXT_extended_dynamic_state ===
21625
21626 // wrapper function for command vkCmdSetCullModeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCullModeEXT.html
21627 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
21628 VULKAN_HPP_INLINE void CommandBuffer::setCullModeEXT( CullModeFlags cullMode, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
21629 {
21630 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
21631 d.vkCmdSetCullModeEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkCullModeFlags>( cullMode ) );
21632 }
21633
21634 // wrapper function for command vkCmdSetFrontFaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFrontFaceEXT.html
21635 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
21636 VULKAN_HPP_INLINE void CommandBuffer::setFrontFaceEXT( FrontFace frontFace, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
21637 {
21638 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
21639 d.vkCmdSetFrontFaceEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkFrontFace>( frontFace ) );
21640 }
21641
21642 // wrapper function for command vkCmdSetPrimitiveTopologyEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPrimitiveTopologyEXT.html
21643 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
21644 VULKAN_HPP_INLINE void CommandBuffer::setPrimitiveTopologyEXT( PrimitiveTopology primitiveTopology, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
21645 {
21646 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
21647 d.vkCmdSetPrimitiveTopologyEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkPrimitiveTopology>( primitiveTopology ) );
21648 }
21649
21650 // wrapper function for command vkCmdSetViewportWithCountEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWithCountEXT.html
21651 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
21652 VULKAN_HPP_INLINE void
21653 CommandBuffer::setViewportWithCountEXT( uint32_t viewportCount, const Viewport * pViewports, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
21654 {
21655 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
21656 d.vkCmdSetViewportWithCountEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), viewportCount, reinterpret_cast<const VkViewport *>( pViewports ) );
21657 }
21658
21659 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
21660 // wrapper function for command vkCmdSetViewportWithCountEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWithCountEXT.html
21661 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
21662 VULKAN_HPP_INLINE void CommandBuffer::setViewportWithCountEXT( ArrayProxy<const Viewport> const & viewports, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
21663 {
21664 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
21665 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
21666 VULKAN_HPP_ASSERT( d.vkCmdSetViewportWithCountEXT &&
21667 "Function <vkCmdSetViewportWithCountEXT> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" );
21668 # endif
21669
21670 d.vkCmdSetViewportWithCountEXT( m_commandBuffer, viewports.size(), reinterpret_cast<const VkViewport *>( viewports.data() ) );
21671 }
21672 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
21673
21674 // wrapper function for command vkCmdSetScissorWithCountEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetScissorWithCountEXT.html
21675 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
21676 VULKAN_HPP_INLINE void CommandBuffer::setScissorWithCountEXT( uint32_t scissorCount, const Rect2D * pScissors, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
21677 {
21678 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
21679 d.vkCmdSetScissorWithCountEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), scissorCount, reinterpret_cast<const VkRect2D *>( pScissors ) );
21680 }
21681
21682 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
21683 // wrapper function for command vkCmdSetScissorWithCountEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetScissorWithCountEXT.html
21684 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
21685 VULKAN_HPP_INLINE void CommandBuffer::setScissorWithCountEXT( ArrayProxy<const Rect2D> const & scissors, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
21686 {
21687 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
21688 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
21689 VULKAN_HPP_ASSERT( d.vkCmdSetScissorWithCountEXT &&
21690 "Function <vkCmdSetScissorWithCountEXT> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" );
21691 # endif
21692
21693 d.vkCmdSetScissorWithCountEXT( m_commandBuffer, scissors.size(), reinterpret_cast<const VkRect2D *>( scissors.data() ) );
21694 }
21695 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
21696
21697 // wrapper function for command vkCmdBindVertexBuffers2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers2EXT.html
21698 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
21699 VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers2EXT( uint32_t firstBinding,
21700 uint32_t bindingCount,
21701 const Buffer * pBuffers,
21702 const DeviceSize * pOffsets,
21703 const DeviceSize * pSizes,
21704 const DeviceSize * pStrides,
21705 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
21706 {
21707 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
21708 d.vkCmdBindVertexBuffers2EXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
21709 firstBinding,
21710 bindingCount,
21711 reinterpret_cast<const VkBuffer *>( pBuffers ),
21712 reinterpret_cast<const VkDeviceSize *>( pOffsets ),
21713 reinterpret_cast<const VkDeviceSize *>( pSizes ),
21714 reinterpret_cast<const VkDeviceSize *>( pStrides ) );
21715 }
21716
21717 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
21718 // wrapper function for command vkCmdBindVertexBuffers2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers2EXT.html
21719 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
21720 VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers2EXT( uint32_t firstBinding,
21721 ArrayProxy<const Buffer> const & buffers,
21722 ArrayProxy<const DeviceSize> const & offsets,
21723 ArrayProxy<const DeviceSize> const & sizes,
21724 ArrayProxy<const DeviceSize> const & strides,
21725 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
21726 {
21727 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
21728 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
21729 VULKAN_HPP_ASSERT( d.vkCmdBindVertexBuffers2EXT &&
21730 "Function <vkCmdBindVertexBuffers2EXT> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" );
21731 # endif
21732 # ifdef VULKAN_HPP_NO_EXCEPTIONS
21733 VULKAN_HPP_ASSERT( buffers.size() == offsets.size() );
21734 VULKAN_HPP_ASSERT( sizes.empty() || buffers.size() == sizes.size() );
21735 VULKAN_HPP_ASSERT( strides.empty() || buffers.size() == strides.size() );
21736 # else
21737 if ( buffers.size() != offsets.size() )
21738 {
21739 throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers2EXT: buffers.size() != offsets.size()" );
21740 }
21741 if ( !sizes.empty() && buffers.size() != sizes.size() )
21742 {
21743 throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers2EXT: buffers.size() != sizes.size()" );
21744 }
21745 if ( !strides.empty() && buffers.size() != strides.size() )
21746 {
21747 throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers2EXT: buffers.size() != strides.size()" );
21748 }
21749 # endif /*VULKAN_HPP_NO_EXCEPTIONS*/
21750
21751 d.vkCmdBindVertexBuffers2EXT( m_commandBuffer,
21752 firstBinding,
21753 buffers.size(),
21754 reinterpret_cast<const VkBuffer *>( buffers.data() ),
21755 reinterpret_cast<const VkDeviceSize *>( offsets.data() ),
21756 reinterpret_cast<const VkDeviceSize *>( sizes.data() ),
21757 reinterpret_cast<const VkDeviceSize *>( strides.data() ) );
21758 }
21759 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
21760
21761 // wrapper function for command vkCmdSetDepthTestEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthTestEnableEXT.html
21762 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
21763 VULKAN_HPP_INLINE void CommandBuffer::setDepthTestEnableEXT( Bool32 depthTestEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
21764 {
21765 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
21766 d.vkCmdSetDepthTestEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( depthTestEnable ) );
21767 }
21768
21769 // wrapper function for command vkCmdSetDepthWriteEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthWriteEnableEXT.html
21770 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
21771 VULKAN_HPP_INLINE void CommandBuffer::setDepthWriteEnableEXT( Bool32 depthWriteEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
21772 {
21773 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
21774 d.vkCmdSetDepthWriteEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( depthWriteEnable ) );
21775 }
21776
21777 // wrapper function for command vkCmdSetDepthCompareOpEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthCompareOpEXT.html
21778 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
21779 VULKAN_HPP_INLINE void CommandBuffer::setDepthCompareOpEXT( CompareOp depthCompareOp, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
21780 {
21781 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
21782 d.vkCmdSetDepthCompareOpEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkCompareOp>( depthCompareOp ) );
21783 }
21784
21785 // wrapper function for command vkCmdSetDepthBoundsTestEnableEXT, see
21786 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBoundsTestEnableEXT.html
21787 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
21788 VULKAN_HPP_INLINE void CommandBuffer::setDepthBoundsTestEnableEXT( Bool32 depthBoundsTestEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
21789 {
21790 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
21791 d.vkCmdSetDepthBoundsTestEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( depthBoundsTestEnable ) );
21792 }
21793
21794 // wrapper function for command vkCmdSetStencilTestEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilTestEnableEXT.html
21795 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
21796 VULKAN_HPP_INLINE void CommandBuffer::setStencilTestEnableEXT( Bool32 stencilTestEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
21797 {
21798 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
21799 d.vkCmdSetStencilTestEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( stencilTestEnable ) );
21800 }
21801
21802 // wrapper function for command vkCmdSetStencilOpEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilOpEXT.html
21803 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
21804 VULKAN_HPP_INLINE void CommandBuffer::setStencilOpEXT(
21805 StencilFaceFlags faceMask, StencilOp failOp, StencilOp passOp, StencilOp depthFailOp, CompareOp compareOp, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
21806 {
21807 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
21808 d.vkCmdSetStencilOpEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
21809 static_cast<VkStencilFaceFlags>( faceMask ),
21810 static_cast<VkStencilOp>( failOp ),
21811 static_cast<VkStencilOp>( passOp ),
21812 static_cast<VkStencilOp>( depthFailOp ),
21813 static_cast<VkCompareOp>( compareOp ) );
21814 }
21815
21816 //=== VK_KHR_deferred_host_operations ===
21817
21818 // wrapper function for command vkCreateDeferredOperationKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDeferredOperationKHR.html
21819 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
21820 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createDeferredOperationKHR( const AllocationCallbacks * pAllocator,
21821 DeferredOperationKHR * pDeferredOperation,
21822 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
21823 {
21824 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
21825 return static_cast<Result>( d.vkCreateDeferredOperationKHR( static_cast<VkDevice>( m_device ),
21826 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
21827 reinterpret_cast<VkDeferredOperationKHR *>( pDeferredOperation ) ) );
21828 }
21829
21830 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
21831 // wrapper function for command vkCreateDeferredOperationKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDeferredOperationKHR.html
21832 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
21833 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<DeferredOperationKHR>::type
21834 Device::createDeferredOperationKHR( Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
21835 {
21836 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
21837 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
21838 VULKAN_HPP_ASSERT( d.vkCreateDeferredOperationKHR && "Function <vkCreateDeferredOperationKHR> requires <VK_KHR_deferred_host_operations>" );
21839 # endif
21840
21841 DeferredOperationKHR deferredOperation;
21842 Result result = static_cast<Result>( d.vkCreateDeferredOperationKHR(
21843 m_device, reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ), reinterpret_cast<VkDeferredOperationKHR *>( &deferredOperation ) ) );
21844 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDeferredOperationKHR" );
21845
21846 return detail::createResultValueType( result, std::move( deferredOperation ) );
21847 }
21848
21849 # ifndef VULKAN_HPP_NO_SMART_HANDLE
21850 // wrapper function for command vkCreateDeferredOperationKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDeferredOperationKHR.html
21851 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
21852 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<DeferredOperationKHR, Dispatch>>::type
21853 Device::createDeferredOperationKHRUnique( Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
21854 {
21855 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
21856 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
21857 VULKAN_HPP_ASSERT( d.vkCreateDeferredOperationKHR && "Function <vkCreateDeferredOperationKHR> requires <VK_KHR_deferred_host_operations>" );
21858 # endif
21859
21860 DeferredOperationKHR deferredOperation;
21861 Result result = static_cast<Result>( d.vkCreateDeferredOperationKHR(
21862 m_device, reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ), reinterpret_cast<VkDeferredOperationKHR *>( &deferredOperation ) ) );
21863 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDeferredOperationKHRUnique" );
21864
21865 return detail::createResultValueType(
21866 result, UniqueHandle<DeferredOperationKHR, Dispatch>( deferredOperation, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
21867 }
21868 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
21869 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
21870
21871 // wrapper function for command vkDestroyDeferredOperationKHR, see
21872 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDeferredOperationKHR.html
21873 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
21874 VULKAN_HPP_INLINE void
21875 Device::destroyDeferredOperationKHR( DeferredOperationKHR operation, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
21876 {
21877 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
21878 d.vkDestroyDeferredOperationKHR(
21879 static_cast<VkDevice>( m_device ), static_cast<VkDeferredOperationKHR>( operation ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
21880 }
21881
21882 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
21883 // wrapper function for command vkDestroyDeferredOperationKHR, see
21884 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDeferredOperationKHR.html
21885 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
21886 VULKAN_HPP_INLINE void Device::destroyDeferredOperationKHR( DeferredOperationKHR operation,
21887 Optional<const AllocationCallbacks> allocator,
21888 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
21889 {
21890 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
21891 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
21892 VULKAN_HPP_ASSERT( d.vkDestroyDeferredOperationKHR && "Function <vkDestroyDeferredOperationKHR> requires <VK_KHR_deferred_host_operations>" );
21893 # endif
21894
21895 d.vkDestroyDeferredOperationKHR(
21896 m_device, static_cast<VkDeferredOperationKHR>( operation ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
21897 }
21898 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
21899
21900 // wrapper function for command vkDestroyDeferredOperationKHR, see
21901 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDeferredOperationKHR.html
21902 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
21903 VULKAN_HPP_INLINE void Device::destroy( DeferredOperationKHR operation, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
21904 {
21905 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
21906 d.vkDestroyDeferredOperationKHR(
21907 static_cast<VkDevice>( m_device ), static_cast<VkDeferredOperationKHR>( operation ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
21908 }
21909
21910 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
21911 // wrapper function for command vkDestroyDeferredOperationKHR, see
21912 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDeferredOperationKHR.html
21913 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
21914 VULKAN_HPP_INLINE void
21915 Device::destroy( DeferredOperationKHR operation, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
21916 {
21917 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
21918 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
21919 VULKAN_HPP_ASSERT( d.vkDestroyDeferredOperationKHR && "Function <vkDestroyDeferredOperationKHR> requires <VK_KHR_deferred_host_operations>" );
21920 # endif
21921
21922 d.vkDestroyDeferredOperationKHR(
21923 m_device, static_cast<VkDeferredOperationKHR>( operation ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
21924 }
21925 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
21926
21927 // wrapper function for command vkGetDeferredOperationMaxConcurrencyKHR, see
21928 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeferredOperationMaxConcurrencyKHR.html
21929 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
21930 VULKAN_HPP_INLINE uint32_t Device::getDeferredOperationMaxConcurrencyKHR( DeferredOperationKHR operation, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
21931 {
21932 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
21933 return d.vkGetDeferredOperationMaxConcurrencyKHR( static_cast<VkDevice>( m_device ), static_cast<VkDeferredOperationKHR>( operation ) );
21934 }
21935
21936 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
21937 // wrapper function for command vkGetDeferredOperationResultKHR, see
21938 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeferredOperationResultKHR.html
21939 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
21940 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getDeferredOperationResultKHR( DeferredOperationKHR operation,
21941 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
21942 {
21943 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
21944 return static_cast<Result>( d.vkGetDeferredOperationResultKHR( static_cast<VkDevice>( m_device ), static_cast<VkDeferredOperationKHR>( operation ) ) );
21945 }
21946 #else
21947 // wrapper function for command vkGetDeferredOperationResultKHR, see
21948 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeferredOperationResultKHR.html
21949 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
21950 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getDeferredOperationResultKHR( DeferredOperationKHR operation, Dispatch const & d ) const
21951 {
21952 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
21953 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
21954 VULKAN_HPP_ASSERT( d.vkGetDeferredOperationResultKHR && "Function <vkGetDeferredOperationResultKHR> requires <VK_KHR_deferred_host_operations>" );
21955 # endif
21956
21957 Result result = static_cast<Result>( d.vkGetDeferredOperationResultKHR( m_device, static_cast<VkDeferredOperationKHR>( operation ) ) );
21958 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getDeferredOperationResultKHR", { Result::eSuccess, Result::eNotReady } );
21959
21960 return static_cast<Result>( result );
21961 }
21962 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
21963
21964 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
21965 // wrapper function for command vkDeferredOperationJoinKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDeferredOperationJoinKHR.html
21966 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
21967 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::deferredOperationJoinKHR( DeferredOperationKHR operation, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
21968 {
21969 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
21970 return static_cast<Result>( d.vkDeferredOperationJoinKHR( static_cast<VkDevice>( m_device ), static_cast<VkDeferredOperationKHR>( operation ) ) );
21971 }
21972 #else
21973 // wrapper function for command vkDeferredOperationJoinKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDeferredOperationJoinKHR.html
21974 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
21975 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::deferredOperationJoinKHR( DeferredOperationKHR operation, Dispatch const & d ) const
21976 {
21977 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
21978 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
21979 VULKAN_HPP_ASSERT( d.vkDeferredOperationJoinKHR && "Function <vkDeferredOperationJoinKHR> requires <VK_KHR_deferred_host_operations>" );
21980 # endif
21981
21982 Result result = static_cast<Result>( d.vkDeferredOperationJoinKHR( m_device, static_cast<VkDeferredOperationKHR>( operation ) ) );
21983 detail::resultCheck(
21984 result, VULKAN_HPP_NAMESPACE_STRING "::Device::deferredOperationJoinKHR", { Result::eSuccess, Result::eThreadDoneKHR, Result::eThreadIdleKHR } );
21985
21986 return static_cast<Result>( result );
21987 }
21988 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
21989
21990 //=== VK_KHR_pipeline_executable_properties ===
21991
21992 // wrapper function for command vkGetPipelineExecutablePropertiesKHR, see
21993 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutablePropertiesKHR.html
21994 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
21995 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getPipelineExecutablePropertiesKHR( const PipelineInfoKHR * pPipelineInfo,
21996 uint32_t * pExecutableCount,
21997 PipelineExecutablePropertiesKHR * pProperties,
21998 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
21999 {
22000 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
22001 return static_cast<Result>( d.vkGetPipelineExecutablePropertiesKHR( static_cast<VkDevice>( m_device ),
22002 reinterpret_cast<const VkPipelineInfoKHR *>( pPipelineInfo ),
22003 pExecutableCount,
22004 reinterpret_cast<VkPipelineExecutablePropertiesKHR *>( pProperties ) ) );
22005 }
22006
22007 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
22008 // wrapper function for command vkGetPipelineExecutablePropertiesKHR, see
22009 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutablePropertiesKHR.html
22010 template <
22011 typename PipelineExecutablePropertiesKHRAllocator,
22012 typename Dispatch,
22013 typename std::enable_if<std::is_same<typename PipelineExecutablePropertiesKHRAllocator::value_type, PipelineExecutablePropertiesKHR>::value, int>::type,
22014 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
22015 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<PipelineExecutablePropertiesKHR, PipelineExecutablePropertiesKHRAllocator>>::type
22016 Device::getPipelineExecutablePropertiesKHR( const PipelineInfoKHR & pipelineInfo, Dispatch const & d ) const
22017 {
22018 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
22019 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
22020 VULKAN_HPP_ASSERT( d.vkGetPipelineExecutablePropertiesKHR &&
22021 "Function <vkGetPipelineExecutablePropertiesKHR> requires <VK_KHR_pipeline_executable_properties>" );
22022 # endif
22023
22024 std::vector<PipelineExecutablePropertiesKHR, PipelineExecutablePropertiesKHRAllocator> properties;
22025 uint32_t executableCount;
22026 Result result;
22027 do
22028 {
22029 result = static_cast<Result>(
22030 d.vkGetPipelineExecutablePropertiesKHR( m_device, reinterpret_cast<const VkPipelineInfoKHR *>( &pipelineInfo ), &executableCount, nullptr ) );
22031 if ( ( result == Result::eSuccess ) && executableCount )
22032 {
22033 properties.resize( executableCount );
22034 result = static_cast<Result>( d.vkGetPipelineExecutablePropertiesKHR( m_device,
22035 reinterpret_cast<const VkPipelineInfoKHR *>( &pipelineInfo ),
22036 &executableCount,
22037 reinterpret_cast<VkPipelineExecutablePropertiesKHR *>( properties.data() ) ) );
22038 }
22039 } while ( result == Result::eIncomplete );
22040 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineExecutablePropertiesKHR" );
22041 VULKAN_HPP_ASSERT( executableCount <= properties.size() );
22042 if ( executableCount < properties.size() )
22043 {
22044 properties.resize( executableCount );
22045 }
22046 return detail::createResultValueType( result, std::move( properties ) );
22047 }
22048
22049 // wrapper function for command vkGetPipelineExecutablePropertiesKHR, see
22050 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutablePropertiesKHR.html
22051 template <
22052 typename PipelineExecutablePropertiesKHRAllocator,
22053 typename Dispatch,
22054 typename std::enable_if<std::is_same<typename PipelineExecutablePropertiesKHRAllocator::value_type, PipelineExecutablePropertiesKHR>::value, int>::type,
22055 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
22056 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<PipelineExecutablePropertiesKHR, PipelineExecutablePropertiesKHRAllocator>>::type
22057 Device::getPipelineExecutablePropertiesKHR( const PipelineInfoKHR & pipelineInfo,
22058 PipelineExecutablePropertiesKHRAllocator & pipelineExecutablePropertiesKHRAllocator,
22059 Dispatch const & d ) const
22060 {
22061 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
22062 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
22063 VULKAN_HPP_ASSERT( d.vkGetPipelineExecutablePropertiesKHR &&
22064 "Function <vkGetPipelineExecutablePropertiesKHR> requires <VK_KHR_pipeline_executable_properties>" );
22065 # endif
22066
22067 std::vector<PipelineExecutablePropertiesKHR, PipelineExecutablePropertiesKHRAllocator> properties( pipelineExecutablePropertiesKHRAllocator );
22068 uint32_t executableCount;
22069 Result result;
22070 do
22071 {
22072 result = static_cast<Result>(
22073 d.vkGetPipelineExecutablePropertiesKHR( m_device, reinterpret_cast<const VkPipelineInfoKHR *>( &pipelineInfo ), &executableCount, nullptr ) );
22074 if ( ( result == Result::eSuccess ) && executableCount )
22075 {
22076 properties.resize( executableCount );
22077 result = static_cast<Result>( d.vkGetPipelineExecutablePropertiesKHR( m_device,
22078 reinterpret_cast<const VkPipelineInfoKHR *>( &pipelineInfo ),
22079 &executableCount,
22080 reinterpret_cast<VkPipelineExecutablePropertiesKHR *>( properties.data() ) ) );
22081 }
22082 } while ( result == Result::eIncomplete );
22083 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineExecutablePropertiesKHR" );
22084 VULKAN_HPP_ASSERT( executableCount <= properties.size() );
22085 if ( executableCount < properties.size() )
22086 {
22087 properties.resize( executableCount );
22088 }
22089 return detail::createResultValueType( result, std::move( properties ) );
22090 }
22091 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
22092
22093 // wrapper function for command vkGetPipelineExecutableStatisticsKHR, see
22094 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutableStatisticsKHR.html
22095 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
22096 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getPipelineExecutableStatisticsKHR( const PipelineExecutableInfoKHR * pExecutableInfo,
22097 uint32_t * pStatisticCount,
22098 PipelineExecutableStatisticKHR * pStatistics,
22099 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
22100 {
22101 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
22102 return static_cast<Result>( d.vkGetPipelineExecutableStatisticsKHR( static_cast<VkDevice>( m_device ),
22103 reinterpret_cast<const VkPipelineExecutableInfoKHR *>( pExecutableInfo ),
22104 pStatisticCount,
22105 reinterpret_cast<VkPipelineExecutableStatisticKHR *>( pStatistics ) ) );
22106 }
22107
22108 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
22109 // wrapper function for command vkGetPipelineExecutableStatisticsKHR, see
22110 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutableStatisticsKHR.html
22111 template <
22112 typename PipelineExecutableStatisticKHRAllocator,
22113 typename Dispatch,
22114 typename std::enable_if<std::is_same<typename PipelineExecutableStatisticKHRAllocator::value_type, PipelineExecutableStatisticKHR>::value, int>::type,
22115 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
22116 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<PipelineExecutableStatisticKHR, PipelineExecutableStatisticKHRAllocator>>::type
22117 Device::getPipelineExecutableStatisticsKHR( const PipelineExecutableInfoKHR & executableInfo, Dispatch const & d ) const
22118 {
22119 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
22120 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
22121 VULKAN_HPP_ASSERT( d.vkGetPipelineExecutableStatisticsKHR &&
22122 "Function <vkGetPipelineExecutableStatisticsKHR> requires <VK_KHR_pipeline_executable_properties>" );
22123 # endif
22124
22125 std::vector<PipelineExecutableStatisticKHR, PipelineExecutableStatisticKHRAllocator> statistics;
22126 uint32_t statisticCount;
22127 Result result;
22128 do
22129 {
22130 result = static_cast<Result>( d.vkGetPipelineExecutableStatisticsKHR(
22131 m_device, reinterpret_cast<const VkPipelineExecutableInfoKHR *>( &executableInfo ), &statisticCount, nullptr ) );
22132 if ( ( result == Result::eSuccess ) && statisticCount )
22133 {
22134 statistics.resize( statisticCount );
22135 result = static_cast<Result>( d.vkGetPipelineExecutableStatisticsKHR( m_device,
22136 reinterpret_cast<const VkPipelineExecutableInfoKHR *>( &executableInfo ),
22137 &statisticCount,
22138 reinterpret_cast<VkPipelineExecutableStatisticKHR *>( statistics.data() ) ) );
22139 }
22140 } while ( result == Result::eIncomplete );
22141 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineExecutableStatisticsKHR" );
22142 VULKAN_HPP_ASSERT( statisticCount <= statistics.size() );
22143 if ( statisticCount < statistics.size() )
22144 {
22145 statistics.resize( statisticCount );
22146 }
22147 return detail::createResultValueType( result, std::move( statistics ) );
22148 }
22149
22150 // wrapper function for command vkGetPipelineExecutableStatisticsKHR, see
22151 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutableStatisticsKHR.html
22152 template <
22153 typename PipelineExecutableStatisticKHRAllocator,
22154 typename Dispatch,
22155 typename std::enable_if<std::is_same<typename PipelineExecutableStatisticKHRAllocator::value_type, PipelineExecutableStatisticKHR>::value, int>::type,
22156 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
22157 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<PipelineExecutableStatisticKHR, PipelineExecutableStatisticKHRAllocator>>::type
22158 Device::getPipelineExecutableStatisticsKHR( const PipelineExecutableInfoKHR & executableInfo,
22159 PipelineExecutableStatisticKHRAllocator & pipelineExecutableStatisticKHRAllocator,
22160 Dispatch const & d ) const
22161 {
22162 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
22163 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
22164 VULKAN_HPP_ASSERT( d.vkGetPipelineExecutableStatisticsKHR &&
22165 "Function <vkGetPipelineExecutableStatisticsKHR> requires <VK_KHR_pipeline_executable_properties>" );
22166 # endif
22167
22168 std::vector<PipelineExecutableStatisticKHR, PipelineExecutableStatisticKHRAllocator> statistics( pipelineExecutableStatisticKHRAllocator );
22169 uint32_t statisticCount;
22170 Result result;
22171 do
22172 {
22173 result = static_cast<Result>( d.vkGetPipelineExecutableStatisticsKHR(
22174 m_device, reinterpret_cast<const VkPipelineExecutableInfoKHR *>( &executableInfo ), &statisticCount, nullptr ) );
22175 if ( ( result == Result::eSuccess ) && statisticCount )
22176 {
22177 statistics.resize( statisticCount );
22178 result = static_cast<Result>( d.vkGetPipelineExecutableStatisticsKHR( m_device,
22179 reinterpret_cast<const VkPipelineExecutableInfoKHR *>( &executableInfo ),
22180 &statisticCount,
22181 reinterpret_cast<VkPipelineExecutableStatisticKHR *>( statistics.data() ) ) );
22182 }
22183 } while ( result == Result::eIncomplete );
22184 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineExecutableStatisticsKHR" );
22185 VULKAN_HPP_ASSERT( statisticCount <= statistics.size() );
22186 if ( statisticCount < statistics.size() )
22187 {
22188 statistics.resize( statisticCount );
22189 }
22190 return detail::createResultValueType( result, std::move( statistics ) );
22191 }
22192 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
22193
22194 // wrapper function for command vkGetPipelineExecutableInternalRepresentationsKHR, see
22195 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutableInternalRepresentationsKHR.html
22196 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
22197 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
22198 Device::getPipelineExecutableInternalRepresentationsKHR( const PipelineExecutableInfoKHR * pExecutableInfo,
22199 uint32_t * pInternalRepresentationCount,
22200 PipelineExecutableInternalRepresentationKHR * pInternalRepresentations,
22201 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
22202 {
22203 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
22204 return static_cast<Result>(
22205 d.vkGetPipelineExecutableInternalRepresentationsKHR( static_cast<VkDevice>( m_device ),
22206 reinterpret_cast<const VkPipelineExecutableInfoKHR *>( pExecutableInfo ),
22207 pInternalRepresentationCount,
22208 reinterpret_cast<VkPipelineExecutableInternalRepresentationKHR *>( pInternalRepresentations ) ) );
22209 }
22210
22211 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
22212 // wrapper function for command vkGetPipelineExecutableInternalRepresentationsKHR, see
22213 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutableInternalRepresentationsKHR.html
22214 template <typename PipelineExecutableInternalRepresentationKHRAllocator,
22215 typename Dispatch,
22216 typename std::enable_if<
22217 std::is_same<typename PipelineExecutableInternalRepresentationKHRAllocator::value_type, PipelineExecutableInternalRepresentationKHR>::value,
22218 int>::type,
22219 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
22220 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
22221 typename ResultValueType<std::vector<PipelineExecutableInternalRepresentationKHR, PipelineExecutableInternalRepresentationKHRAllocator>>::type
22222 Device::getPipelineExecutableInternalRepresentationsKHR( const PipelineExecutableInfoKHR & executableInfo, Dispatch const & d ) const
22223 {
22224 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
22225 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
22226 VULKAN_HPP_ASSERT( d.vkGetPipelineExecutableInternalRepresentationsKHR &&
22227 "Function <vkGetPipelineExecutableInternalRepresentationsKHR> requires <VK_KHR_pipeline_executable_properties>" );
22228 # endif
22229
22230 std::vector<PipelineExecutableInternalRepresentationKHR, PipelineExecutableInternalRepresentationKHRAllocator> internalRepresentations;
22231 uint32_t internalRepresentationCount;
22232 Result result;
22233 do
22234 {
22235 result = static_cast<Result>( d.vkGetPipelineExecutableInternalRepresentationsKHR(
22236 m_device, reinterpret_cast<const VkPipelineExecutableInfoKHR *>( &executableInfo ), &internalRepresentationCount, nullptr ) );
22237 if ( ( result == Result::eSuccess ) && internalRepresentationCount )
22238 {
22239 internalRepresentations.resize( internalRepresentationCount );
22240 result = static_cast<Result>( d.vkGetPipelineExecutableInternalRepresentationsKHR(
22241 m_device,
22242 reinterpret_cast<const VkPipelineExecutableInfoKHR *>( &executableInfo ),
22243 &internalRepresentationCount,
22244 reinterpret_cast<VkPipelineExecutableInternalRepresentationKHR *>( internalRepresentations.data() ) ) );
22245 }
22246 } while ( result == Result::eIncomplete );
22247 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineExecutableInternalRepresentationsKHR" );
22248 VULKAN_HPP_ASSERT( internalRepresentationCount <= internalRepresentations.size() );
22249 if ( internalRepresentationCount < internalRepresentations.size() )
22250 {
22251 internalRepresentations.resize( internalRepresentationCount );
22252 }
22253 return detail::createResultValueType( result, std::move( internalRepresentations ) );
22254 }
22255
22256 // wrapper function for command vkGetPipelineExecutableInternalRepresentationsKHR, see
22257 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutableInternalRepresentationsKHR.html
22258 template <typename PipelineExecutableInternalRepresentationKHRAllocator,
22259 typename Dispatch,
22260 typename std::enable_if<
22261 std::is_same<typename PipelineExecutableInternalRepresentationKHRAllocator::value_type, PipelineExecutableInternalRepresentationKHR>::value,
22262 int>::type,
22263 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
22264 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
22265 typename ResultValueType<std::vector<PipelineExecutableInternalRepresentationKHR, PipelineExecutableInternalRepresentationKHRAllocator>>::type
22266 Device::getPipelineExecutableInternalRepresentationsKHR(
22267 const PipelineExecutableInfoKHR & executableInfo,
22268 PipelineExecutableInternalRepresentationKHRAllocator & pipelineExecutableInternalRepresentationKHRAllocator,
22269 Dispatch const & d ) const
22270 {
22271 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
22272 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
22273 VULKAN_HPP_ASSERT( d.vkGetPipelineExecutableInternalRepresentationsKHR &&
22274 "Function <vkGetPipelineExecutableInternalRepresentationsKHR> requires <VK_KHR_pipeline_executable_properties>" );
22275 # endif
22276
22277 std::vector<PipelineExecutableInternalRepresentationKHR, PipelineExecutableInternalRepresentationKHRAllocator> internalRepresentations(
22278 pipelineExecutableInternalRepresentationKHRAllocator );
22279 uint32_t internalRepresentationCount;
22280 Result result;
22281 do
22282 {
22283 result = static_cast<Result>( d.vkGetPipelineExecutableInternalRepresentationsKHR(
22284 m_device, reinterpret_cast<const VkPipelineExecutableInfoKHR *>( &executableInfo ), &internalRepresentationCount, nullptr ) );
22285 if ( ( result == Result::eSuccess ) && internalRepresentationCount )
22286 {
22287 internalRepresentations.resize( internalRepresentationCount );
22288 result = static_cast<Result>( d.vkGetPipelineExecutableInternalRepresentationsKHR(
22289 m_device,
22290 reinterpret_cast<const VkPipelineExecutableInfoKHR *>( &executableInfo ),
22291 &internalRepresentationCount,
22292 reinterpret_cast<VkPipelineExecutableInternalRepresentationKHR *>( internalRepresentations.data() ) ) );
22293 }
22294 } while ( result == Result::eIncomplete );
22295 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineExecutableInternalRepresentationsKHR" );
22296 VULKAN_HPP_ASSERT( internalRepresentationCount <= internalRepresentations.size() );
22297 if ( internalRepresentationCount < internalRepresentations.size() )
22298 {
22299 internalRepresentations.resize( internalRepresentationCount );
22300 }
22301 return detail::createResultValueType( result, std::move( internalRepresentations ) );
22302 }
22303 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
22304
22305 //=== VK_EXT_host_image_copy ===
22306
22307 // wrapper function for command vkCopyMemoryToImageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToImageEXT.html
22308 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
22309 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyMemoryToImageEXT( const CopyMemoryToImageInfo * pCopyMemoryToImageInfo,
22310 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
22311 {
22312 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
22313 return static_cast<Result>(
22314 d.vkCopyMemoryToImageEXT( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkCopyMemoryToImageInfo *>( pCopyMemoryToImageInfo ) ) );
22315 }
22316
22317 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
22318 // wrapper function for command vkCopyMemoryToImageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToImageEXT.html
22319 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
22320 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
22321 Device::copyMemoryToImageEXT( const CopyMemoryToImageInfo & copyMemoryToImageInfo, Dispatch const & d ) const
22322 {
22323 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
22324 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
22325 VULKAN_HPP_ASSERT( d.vkCopyMemoryToImageEXT && "Function <vkCopyMemoryToImageEXT> requires <VK_EXT_host_image_copy> or <VK_VERSION_1_4>" );
22326 # endif
22327
22328 Result result = static_cast<Result>( d.vkCopyMemoryToImageEXT( m_device, reinterpret_cast<const VkCopyMemoryToImageInfo *>( &copyMemoryToImageInfo ) ) );
22329 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::copyMemoryToImageEXT" );
22330
22331 return detail::createResultValueType( result );
22332 }
22333 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
22334
22335 // wrapper function for command vkCopyImageToMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToMemoryEXT.html
22336 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
22337 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyImageToMemoryEXT( const CopyImageToMemoryInfo * pCopyImageToMemoryInfo,
22338 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
22339 {
22340 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
22341 return static_cast<Result>(
22342 d.vkCopyImageToMemoryEXT( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkCopyImageToMemoryInfo *>( pCopyImageToMemoryInfo ) ) );
22343 }
22344
22345 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
22346 // wrapper function for command vkCopyImageToMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToMemoryEXT.html
22347 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
22348 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
22349 Device::copyImageToMemoryEXT( const CopyImageToMemoryInfo & copyImageToMemoryInfo, Dispatch const & d ) const
22350 {
22351 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
22352 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
22353 VULKAN_HPP_ASSERT( d.vkCopyImageToMemoryEXT && "Function <vkCopyImageToMemoryEXT> requires <VK_EXT_host_image_copy> or <VK_VERSION_1_4>" );
22354 # endif
22355
22356 Result result = static_cast<Result>( d.vkCopyImageToMemoryEXT( m_device, reinterpret_cast<const VkCopyImageToMemoryInfo *>( &copyImageToMemoryInfo ) ) );
22357 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::copyImageToMemoryEXT" );
22358
22359 return detail::createResultValueType( result );
22360 }
22361 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
22362
22363 // wrapper function for command vkCopyImageToImageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToImageEXT.html
22364 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
22365 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyImageToImageEXT( const CopyImageToImageInfo * pCopyImageToImageInfo,
22366 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
22367 {
22368 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
22369 return static_cast<Result>(
22370 d.vkCopyImageToImageEXT( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkCopyImageToImageInfo *>( pCopyImageToImageInfo ) ) );
22371 }
22372
22373 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
22374 // wrapper function for command vkCopyImageToImageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToImageEXT.html
22375 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
22376 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
22377 Device::copyImageToImageEXT( const CopyImageToImageInfo & copyImageToImageInfo, Dispatch const & d ) const
22378 {
22379 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
22380 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
22381 VULKAN_HPP_ASSERT( d.vkCopyImageToImageEXT && "Function <vkCopyImageToImageEXT> requires <VK_EXT_host_image_copy> or <VK_VERSION_1_4>" );
22382 # endif
22383
22384 Result result = static_cast<Result>( d.vkCopyImageToImageEXT( m_device, reinterpret_cast<const VkCopyImageToImageInfo *>( &copyImageToImageInfo ) ) );
22385 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::copyImageToImageEXT" );
22386
22387 return detail::createResultValueType( result );
22388 }
22389 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
22390
22391 // wrapper function for command vkTransitionImageLayoutEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkTransitionImageLayoutEXT.html
22392 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
22393 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::transitionImageLayoutEXT( uint32_t transitionCount,
22394 const HostImageLayoutTransitionInfo * pTransitions,
22395 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
22396 {
22397 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
22398 return static_cast<Result>( d.vkTransitionImageLayoutEXT(
22399 static_cast<VkDevice>( m_device ), transitionCount, reinterpret_cast<const VkHostImageLayoutTransitionInfo *>( pTransitions ) ) );
22400 }
22401
22402 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
22403 // wrapper function for command vkTransitionImageLayoutEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkTransitionImageLayoutEXT.html
22404 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
22405 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
22406 Device::transitionImageLayoutEXT( ArrayProxy<const HostImageLayoutTransitionInfo> const & transitions, Dispatch const & d ) const
22407 {
22408 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
22409 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
22410 VULKAN_HPP_ASSERT( d.vkTransitionImageLayoutEXT && "Function <vkTransitionImageLayoutEXT> requires <VK_EXT_host_image_copy> or <VK_VERSION_1_4>" );
22411 # endif
22412
22413 Result result = static_cast<Result>(
22414 d.vkTransitionImageLayoutEXT( m_device, transitions.size(), reinterpret_cast<const VkHostImageLayoutTransitionInfo *>( transitions.data() ) ) );
22415 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::transitionImageLayoutEXT" );
22416
22417 return detail::createResultValueType( result );
22418 }
22419 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
22420
22421 // wrapper function for command vkGetImageSubresourceLayout2EXT, see
22422 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2EXT.html
22423 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
22424 VULKAN_HPP_INLINE void Device::getImageSubresourceLayout2EXT( Image image,
22425 const ImageSubresource2 * pSubresource,
22426 SubresourceLayout2 * pLayout,
22427 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
22428 {
22429 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
22430 d.vkGetImageSubresourceLayout2EXT( static_cast<VkDevice>( m_device ),
22431 static_cast<VkImage>( image ),
22432 reinterpret_cast<const VkImageSubresource2 *>( pSubresource ),
22433 reinterpret_cast<VkSubresourceLayout2 *>( pLayout ) );
22434 }
22435
22436 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
22437 // wrapper function for command vkGetImageSubresourceLayout2EXT, see
22438 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2EXT.html
22439 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
22440 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE SubresourceLayout2 Device::getImageSubresourceLayout2EXT( Image image,
22441 const ImageSubresource2 & subresource,
22442 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
22443 {
22444 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
22445 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
22446 VULKAN_HPP_ASSERT(
22447 d.vkGetImageSubresourceLayout2EXT &&
22448 "Function <vkGetImageSubresourceLayout2EXT> requires <VK_EXT_host_image_copy> or <VK_EXT_image_compression_control> or <VK_KHR_maintenance5> or <VK_VERSION_1_4>" );
22449 # endif
22450
22451 SubresourceLayout2 layout;
22452 d.vkGetImageSubresourceLayout2EXT( m_device,
22453 static_cast<VkImage>( image ),
22454 reinterpret_cast<const VkImageSubresource2 *>( &subresource ),
22455 reinterpret_cast<VkSubresourceLayout2 *>( &layout ) );
22456
22457 return layout;
22458 }
22459
22460 // wrapper function for command vkGetImageSubresourceLayout2EXT, see
22461 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2EXT.html
22462 template <typename X, typename Y, typename... Z, typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
22463 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...>
22464 Device::getImageSubresourceLayout2EXT( Image image, const ImageSubresource2 & subresource, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
22465 {
22466 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
22467 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
22468 VULKAN_HPP_ASSERT(
22469 d.vkGetImageSubresourceLayout2EXT &&
22470 "Function <vkGetImageSubresourceLayout2EXT> requires <VK_EXT_host_image_copy> or <VK_EXT_image_compression_control> or <VK_KHR_maintenance5> or <VK_VERSION_1_4>" );
22471 # endif
22472
22473 StructureChain<X, Y, Z...> structureChain;
22474 SubresourceLayout2 & layout = structureChain.template get<SubresourceLayout2>();
22475 d.vkGetImageSubresourceLayout2EXT( m_device,
22476 static_cast<VkImage>( image ),
22477 reinterpret_cast<const VkImageSubresource2 *>( &subresource ),
22478 reinterpret_cast<VkSubresourceLayout2 *>( &layout ) );
22479
22480 return structureChain;
22481 }
22482 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
22483
22484 //=== VK_KHR_map_memory2 ===
22485
22486 // wrapper function for command vkMapMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMapMemory2KHR.html
22487 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
22488 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::mapMemory2KHR( const MemoryMapInfo * pMemoryMapInfo,
22489 void ** ppData,
22490 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
22491 {
22492 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
22493 return static_cast<Result>( d.vkMapMemory2KHR( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkMemoryMapInfo *>( pMemoryMapInfo ), ppData ) );
22494 }
22495
22496 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
22497 // wrapper function for command vkMapMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMapMemory2KHR.html
22498 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
22499 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<void *>::type Device::mapMemory2KHR( const MemoryMapInfo & memoryMapInfo,
22500 Dispatch const & d ) const
22501 {
22502 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
22503 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
22504 VULKAN_HPP_ASSERT( d.vkMapMemory2KHR && "Function <vkMapMemory2KHR> requires <VK_KHR_map_memory2> or <VK_VERSION_1_4>" );
22505 # endif
22506
22507 void * pData;
22508 Result result = static_cast<Result>( d.vkMapMemory2KHR( m_device, reinterpret_cast<const VkMemoryMapInfo *>( &memoryMapInfo ), &pData ) );
22509 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::mapMemory2KHR" );
22510
22511 return detail::createResultValueType( result, std::move( pData ) );
22512 }
22513 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
22514
22515 // wrapper function for command vkUnmapMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnmapMemory2KHR.html
22516 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
22517 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::unmapMemory2KHR( const MemoryUnmapInfo * pMemoryUnmapInfo,
22518 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
22519 {
22520 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
22521 return static_cast<Result>( d.vkUnmapMemory2KHR( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkMemoryUnmapInfo *>( pMemoryUnmapInfo ) ) );
22522 }
22523
22524 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
22525 // wrapper function for command vkUnmapMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnmapMemory2KHR.html
22526 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
22527 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
22528 Device::unmapMemory2KHR( const MemoryUnmapInfo & memoryUnmapInfo, Dispatch const & d ) const
22529 {
22530 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
22531 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
22532 VULKAN_HPP_ASSERT( d.vkUnmapMemory2KHR && "Function <vkUnmapMemory2KHR> requires <VK_KHR_map_memory2> or <VK_VERSION_1_4>" );
22533 # endif
22534
22535 Result result = static_cast<Result>( d.vkUnmapMemory2KHR( m_device, reinterpret_cast<const VkMemoryUnmapInfo *>( &memoryUnmapInfo ) ) );
22536 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::unmapMemory2KHR" );
22537
22538 return detail::createResultValueType( result );
22539 }
22540 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
22541
22542 //=== VK_EXT_swapchain_maintenance1 ===
22543
22544 // wrapper function for command vkReleaseSwapchainImagesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseSwapchainImagesEXT.html
22545 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
22546 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::releaseSwapchainImagesEXT( const ReleaseSwapchainImagesInfoKHR * pReleaseInfo,
22547 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
22548 {
22549 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
22550 return static_cast<Result>(
22551 d.vkReleaseSwapchainImagesEXT( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkReleaseSwapchainImagesInfoKHR *>( pReleaseInfo ) ) );
22552 }
22553
22554 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
22555 // wrapper function for command vkReleaseSwapchainImagesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseSwapchainImagesEXT.html
22556 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
22557 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
22558 Device::releaseSwapchainImagesEXT( const ReleaseSwapchainImagesInfoKHR & releaseInfo, Dispatch const & d ) const
22559 {
22560 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
22561 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
22562 VULKAN_HPP_ASSERT( d.vkReleaseSwapchainImagesEXT &&
22563 "Function <vkReleaseSwapchainImagesEXT> requires <VK_EXT_swapchain_maintenance1> or <VK_KHR_swapchain_maintenance1>" );
22564 # endif
22565
22566 Result result = static_cast<Result>( d.vkReleaseSwapchainImagesEXT( m_device, reinterpret_cast<const VkReleaseSwapchainImagesInfoKHR *>( &releaseInfo ) ) );
22567 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::releaseSwapchainImagesEXT" );
22568
22569 return detail::createResultValueType( result );
22570 }
22571 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
22572
22573 //=== VK_NV_device_generated_commands ===
22574
22575 // wrapper function for command vkGetGeneratedCommandsMemoryRequirementsNV, see
22576 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGeneratedCommandsMemoryRequirementsNV.html
22577 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
22578 VULKAN_HPP_INLINE void Device::getGeneratedCommandsMemoryRequirementsNV( const GeneratedCommandsMemoryRequirementsInfoNV * pInfo,
22579 MemoryRequirements2 * pMemoryRequirements,
22580 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
22581 {
22582 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
22583 d.vkGetGeneratedCommandsMemoryRequirementsNV( static_cast<VkDevice>( m_device ),
22584 reinterpret_cast<const VkGeneratedCommandsMemoryRequirementsInfoNV *>( pInfo ),
22585 reinterpret_cast<VkMemoryRequirements2 *>( pMemoryRequirements ) );
22586 }
22587
22588 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
22589 // wrapper function for command vkGetGeneratedCommandsMemoryRequirementsNV, see
22590 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGeneratedCommandsMemoryRequirementsNV.html
22591 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
22592 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2
22593 Device::getGeneratedCommandsMemoryRequirementsNV( const GeneratedCommandsMemoryRequirementsInfoNV & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
22594 {
22595 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
22596 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
22597 VULKAN_HPP_ASSERT( d.vkGetGeneratedCommandsMemoryRequirementsNV &&
22598 "Function <vkGetGeneratedCommandsMemoryRequirementsNV> requires <VK_NV_device_generated_commands>" );
22599 # endif
22600
22601 MemoryRequirements2 memoryRequirements;
22602 d.vkGetGeneratedCommandsMemoryRequirementsNV( m_device,
22603 reinterpret_cast<const VkGeneratedCommandsMemoryRequirementsInfoNV *>( &info ),
22604 reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
22605
22606 return memoryRequirements;
22607 }
22608
22609 // wrapper function for command vkGetGeneratedCommandsMemoryRequirementsNV, see
22610 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGeneratedCommandsMemoryRequirementsNV.html
22611 template <typename X, typename Y, typename... Z, typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
22612 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...>
22613 Device::getGeneratedCommandsMemoryRequirementsNV( const GeneratedCommandsMemoryRequirementsInfoNV & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
22614 {
22615 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
22616 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
22617 VULKAN_HPP_ASSERT( d.vkGetGeneratedCommandsMemoryRequirementsNV &&
22618 "Function <vkGetGeneratedCommandsMemoryRequirementsNV> requires <VK_NV_device_generated_commands>" );
22619 # endif
22620
22621 StructureChain<X, Y, Z...> structureChain;
22622 MemoryRequirements2 & memoryRequirements = structureChain.template get<MemoryRequirements2>();
22623 d.vkGetGeneratedCommandsMemoryRequirementsNV( m_device,
22624 reinterpret_cast<const VkGeneratedCommandsMemoryRequirementsInfoNV *>( &info ),
22625 reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
22626
22627 return structureChain;
22628 }
22629 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
22630
22631 // wrapper function for command vkCmdPreprocessGeneratedCommandsNV, see
22632 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPreprocessGeneratedCommandsNV.html
22633 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
22634 VULKAN_HPP_INLINE void CommandBuffer::preprocessGeneratedCommandsNV( const GeneratedCommandsInfoNV * pGeneratedCommandsInfo,
22635 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
22636 {
22637 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
22638 d.vkCmdPreprocessGeneratedCommandsNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
22639 reinterpret_cast<const VkGeneratedCommandsInfoNV *>( pGeneratedCommandsInfo ) );
22640 }
22641
22642 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
22643 // wrapper function for command vkCmdPreprocessGeneratedCommandsNV, see
22644 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPreprocessGeneratedCommandsNV.html
22645 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
22646 VULKAN_HPP_INLINE void CommandBuffer::preprocessGeneratedCommandsNV( const GeneratedCommandsInfoNV & generatedCommandsInfo,
22647 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
22648 {
22649 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
22650 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
22651 VULKAN_HPP_ASSERT( d.vkCmdPreprocessGeneratedCommandsNV && "Function <vkCmdPreprocessGeneratedCommandsNV> requires <VK_NV_device_generated_commands>" );
22652 # endif
22653
22654 d.vkCmdPreprocessGeneratedCommandsNV( m_commandBuffer, reinterpret_cast<const VkGeneratedCommandsInfoNV *>( &generatedCommandsInfo ) );
22655 }
22656 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
22657
22658 // wrapper function for command vkCmdExecuteGeneratedCommandsNV, see
22659 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdExecuteGeneratedCommandsNV.html
22660 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
22661 VULKAN_HPP_INLINE void CommandBuffer::executeGeneratedCommandsNV( Bool32 isPreprocessed,
22662 const GeneratedCommandsInfoNV * pGeneratedCommandsInfo,
22663 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
22664 {
22665 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
22666 d.vkCmdExecuteGeneratedCommandsNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
22667 static_cast<VkBool32>( isPreprocessed ),
22668 reinterpret_cast<const VkGeneratedCommandsInfoNV *>( pGeneratedCommandsInfo ) );
22669 }
22670
22671 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
22672 // wrapper function for command vkCmdExecuteGeneratedCommandsNV, see
22673 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdExecuteGeneratedCommandsNV.html
22674 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
22675 VULKAN_HPP_INLINE void CommandBuffer::executeGeneratedCommandsNV( Bool32 isPreprocessed,
22676 const GeneratedCommandsInfoNV & generatedCommandsInfo,
22677 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
22678 {
22679 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
22680 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
22681 VULKAN_HPP_ASSERT( d.vkCmdExecuteGeneratedCommandsNV && "Function <vkCmdExecuteGeneratedCommandsNV> requires <VK_NV_device_generated_commands>" );
22682 # endif
22683
22684 d.vkCmdExecuteGeneratedCommandsNV(
22685 m_commandBuffer, static_cast<VkBool32>( isPreprocessed ), reinterpret_cast<const VkGeneratedCommandsInfoNV *>( &generatedCommandsInfo ) );
22686 }
22687 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
22688
22689 // wrapper function for command vkCmdBindPipelineShaderGroupNV, see
22690 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindPipelineShaderGroupNV.html
22691 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
22692 VULKAN_HPP_INLINE void CommandBuffer::bindPipelineShaderGroupNV( PipelineBindPoint pipelineBindPoint,
22693 Pipeline pipeline,
22694 uint32_t groupIndex,
22695 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
22696 {
22697 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
22698 d.vkCmdBindPipelineShaderGroupNV(
22699 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkPipelineBindPoint>( pipelineBindPoint ), static_cast<VkPipeline>( pipeline ), groupIndex );
22700 }
22701
22702 // wrapper function for command vkCreateIndirectCommandsLayoutNV, see
22703 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectCommandsLayoutNV.html
22704 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
22705 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createIndirectCommandsLayoutNV( const IndirectCommandsLayoutCreateInfoNV * pCreateInfo,
22706 const AllocationCallbacks * pAllocator,
22707 IndirectCommandsLayoutNV * pIndirectCommandsLayout,
22708 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
22709 {
22710 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
22711 return static_cast<Result>( d.vkCreateIndirectCommandsLayoutNV( static_cast<VkDevice>( m_device ),
22712 reinterpret_cast<const VkIndirectCommandsLayoutCreateInfoNV *>( pCreateInfo ),
22713 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
22714 reinterpret_cast<VkIndirectCommandsLayoutNV *>( pIndirectCommandsLayout ) ) );
22715 }
22716
22717 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
22718 // wrapper function for command vkCreateIndirectCommandsLayoutNV, see
22719 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectCommandsLayoutNV.html
22720 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
22721 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<IndirectCommandsLayoutNV>::type Device::createIndirectCommandsLayoutNV(
22722 const IndirectCommandsLayoutCreateInfoNV & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
22723 {
22724 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
22725 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
22726 VULKAN_HPP_ASSERT( d.vkCreateIndirectCommandsLayoutNV && "Function <vkCreateIndirectCommandsLayoutNV> requires <VK_NV_device_generated_commands>" );
22727 # endif
22728
22729 IndirectCommandsLayoutNV indirectCommandsLayout;
22730 Result result = static_cast<Result>( d.vkCreateIndirectCommandsLayoutNV( m_device,
22731 reinterpret_cast<const VkIndirectCommandsLayoutCreateInfoNV *>( &createInfo ),
22732 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
22733 reinterpret_cast<VkIndirectCommandsLayoutNV *>( &indirectCommandsLayout ) ) );
22734 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createIndirectCommandsLayoutNV" );
22735
22736 return detail::createResultValueType( result, std::move( indirectCommandsLayout ) );
22737 }
22738
22739 # ifndef VULKAN_HPP_NO_SMART_HANDLE
22740 // wrapper function for command vkCreateIndirectCommandsLayoutNV, see
22741 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectCommandsLayoutNV.html
22742 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
22743 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<IndirectCommandsLayoutNV, Dispatch>>::type
22744 Device::createIndirectCommandsLayoutNVUnique( const IndirectCommandsLayoutCreateInfoNV & createInfo,
22745 Optional<const AllocationCallbacks> allocator,
22746 Dispatch const & d ) const
22747 {
22748 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
22749 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
22750 VULKAN_HPP_ASSERT( d.vkCreateIndirectCommandsLayoutNV && "Function <vkCreateIndirectCommandsLayoutNV> requires <VK_NV_device_generated_commands>" );
22751 # endif
22752
22753 IndirectCommandsLayoutNV indirectCommandsLayout;
22754 Result result = static_cast<Result>( d.vkCreateIndirectCommandsLayoutNV( m_device,
22755 reinterpret_cast<const VkIndirectCommandsLayoutCreateInfoNV *>( &createInfo ),
22756 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
22757 reinterpret_cast<VkIndirectCommandsLayoutNV *>( &indirectCommandsLayout ) ) );
22758 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createIndirectCommandsLayoutNVUnique" );
22759
22760 return detail::createResultValueType(
22761 result, UniqueHandle<IndirectCommandsLayoutNV, Dispatch>( indirectCommandsLayout, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
22762 }
22763 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
22764 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
22765
22766 // wrapper function for command vkDestroyIndirectCommandsLayoutNV, see
22767 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectCommandsLayoutNV.html
22768 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
22769 VULKAN_HPP_INLINE void Device::destroyIndirectCommandsLayoutNV( IndirectCommandsLayoutNV indirectCommandsLayout,
22770 const AllocationCallbacks * pAllocator,
22771 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
22772 {
22773 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
22774 d.vkDestroyIndirectCommandsLayoutNV( static_cast<VkDevice>( m_device ),
22775 static_cast<VkIndirectCommandsLayoutNV>( indirectCommandsLayout ),
22776 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
22777 }
22778
22779 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
22780 // wrapper function for command vkDestroyIndirectCommandsLayoutNV, see
22781 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectCommandsLayoutNV.html
22782 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
22783 VULKAN_HPP_INLINE void Device::destroyIndirectCommandsLayoutNV( IndirectCommandsLayoutNV indirectCommandsLayout,
22784 Optional<const AllocationCallbacks> allocator,
22785 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
22786 {
22787 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
22788 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
22789 VULKAN_HPP_ASSERT( d.vkDestroyIndirectCommandsLayoutNV && "Function <vkDestroyIndirectCommandsLayoutNV> requires <VK_NV_device_generated_commands>" );
22790 # endif
22791
22792 d.vkDestroyIndirectCommandsLayoutNV(
22793 m_device, static_cast<VkIndirectCommandsLayoutNV>( indirectCommandsLayout ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
22794 }
22795 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
22796
22797 // wrapper function for command vkDestroyIndirectCommandsLayoutNV, see
22798 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectCommandsLayoutNV.html
22799 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
22800 VULKAN_HPP_INLINE void
22801 Device::destroy( IndirectCommandsLayoutNV indirectCommandsLayout, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
22802 {
22803 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
22804 d.vkDestroyIndirectCommandsLayoutNV( static_cast<VkDevice>( m_device ),
22805 static_cast<VkIndirectCommandsLayoutNV>( indirectCommandsLayout ),
22806 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
22807 }
22808
22809 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
22810 // wrapper function for command vkDestroyIndirectCommandsLayoutNV, see
22811 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectCommandsLayoutNV.html
22812 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
22813 VULKAN_HPP_INLINE void Device::destroy( IndirectCommandsLayoutNV indirectCommandsLayout,
22814 Optional<const AllocationCallbacks> allocator,
22815 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
22816 {
22817 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
22818 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
22819 VULKAN_HPP_ASSERT( d.vkDestroyIndirectCommandsLayoutNV && "Function <vkDestroyIndirectCommandsLayoutNV> requires <VK_NV_device_generated_commands>" );
22820 # endif
22821
22822 d.vkDestroyIndirectCommandsLayoutNV(
22823 m_device, static_cast<VkIndirectCommandsLayoutNV>( indirectCommandsLayout ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
22824 }
22825 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
22826
22827 //=== VK_EXT_depth_bias_control ===
22828
22829 // wrapper function for command vkCmdSetDepthBias2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBias2EXT.html
22830 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
22831 VULKAN_HPP_INLINE void CommandBuffer::setDepthBias2EXT( const DepthBiasInfoEXT * pDepthBiasInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
22832 {
22833 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
22834 d.vkCmdSetDepthBias2EXT( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkDepthBiasInfoEXT *>( pDepthBiasInfo ) );
22835 }
22836
22837 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
22838 // wrapper function for command vkCmdSetDepthBias2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBias2EXT.html
22839 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
22840 VULKAN_HPP_INLINE void CommandBuffer::setDepthBias2EXT( const DepthBiasInfoEXT & depthBiasInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
22841 {
22842 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
22843 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
22844 VULKAN_HPP_ASSERT( d.vkCmdSetDepthBias2EXT && "Function <vkCmdSetDepthBias2EXT> requires <VK_EXT_depth_bias_control>" );
22845 # endif
22846
22847 d.vkCmdSetDepthBias2EXT( m_commandBuffer, reinterpret_cast<const VkDepthBiasInfoEXT *>( &depthBiasInfo ) );
22848 }
22849 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
22850
22851 //=== VK_EXT_acquire_drm_display ===
22852
22853 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
22854 // wrapper function for command vkAcquireDrmDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireDrmDisplayEXT.html
22855 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
22856 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::acquireDrmDisplayEXT( int32_t drmFd,
22857 DisplayKHR display,
22858 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
22859 {
22860 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
22861 return static_cast<Result>( d.vkAcquireDrmDisplayEXT( static_cast<VkPhysicalDevice>( m_physicalDevice ), drmFd, static_cast<VkDisplayKHR>( display ) ) );
22862 }
22863 #else
22864 // wrapper function for command vkAcquireDrmDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireDrmDisplayEXT.html
22865 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
22866 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
22867 PhysicalDevice::acquireDrmDisplayEXT( int32_t drmFd, DisplayKHR display, Dispatch const & d ) const
22868 {
22869 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
22870 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
22871 VULKAN_HPP_ASSERT( d.vkAcquireDrmDisplayEXT && "Function <vkAcquireDrmDisplayEXT> requires <VK_EXT_acquire_drm_display>" );
22872 # endif
22873
22874 Result result = static_cast<Result>( d.vkAcquireDrmDisplayEXT( m_physicalDevice, drmFd, static_cast<VkDisplayKHR>( display ) ) );
22875 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::acquireDrmDisplayEXT" );
22876
22877 return detail::createResultValueType( result );
22878 }
22879 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
22880
22881 // wrapper function for command vkGetDrmDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDrmDisplayEXT.html
22882 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
22883 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
22884 PhysicalDevice::getDrmDisplayEXT( int32_t drmFd, uint32_t connectorId, DisplayKHR * display, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
22885 {
22886 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
22887 return static_cast<Result>(
22888 d.vkGetDrmDisplayEXT( static_cast<VkPhysicalDevice>( m_physicalDevice ), drmFd, connectorId, reinterpret_cast<VkDisplayKHR *>( display ) ) );
22889 }
22890
22891 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
22892 // wrapper function for command vkGetDrmDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDrmDisplayEXT.html
22893 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
22894 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<DisplayKHR>::type
22895 PhysicalDevice::getDrmDisplayEXT( int32_t drmFd, uint32_t connectorId, Dispatch const & d ) const
22896 {
22897 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
22898 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
22899 VULKAN_HPP_ASSERT( d.vkGetDrmDisplayEXT && "Function <vkGetDrmDisplayEXT> requires <VK_EXT_acquire_drm_display>" );
22900 # endif
22901
22902 DisplayKHR display;
22903 Result result = static_cast<Result>( d.vkGetDrmDisplayEXT( m_physicalDevice, drmFd, connectorId, reinterpret_cast<VkDisplayKHR *>( &display ) ) );
22904 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDrmDisplayEXT" );
22905
22906 return detail::createResultValueType( result, std::move( display ) );
22907 }
22908
22909 # ifndef VULKAN_HPP_NO_SMART_HANDLE
22910 // wrapper function for command vkGetDrmDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDrmDisplayEXT.html
22911 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
22912 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<DisplayKHR, Dispatch>>::type
22913 PhysicalDevice::getDrmDisplayEXTUnique( int32_t drmFd, uint32_t connectorId, Dispatch const & d ) const
22914 {
22915 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
22916 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
22917 VULKAN_HPP_ASSERT( d.vkGetDrmDisplayEXT && "Function <vkGetDrmDisplayEXT> requires <VK_EXT_acquire_drm_display>" );
22918 # endif
22919
22920 DisplayKHR display;
22921 Result result = static_cast<Result>( d.vkGetDrmDisplayEXT( m_physicalDevice, drmFd, connectorId, reinterpret_cast<VkDisplayKHR *>( &display ) ) );
22922 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDrmDisplayEXTUnique" );
22923
22924 return detail::createResultValueType( result, UniqueHandle<DisplayKHR, Dispatch>( display, detail::ObjectRelease<PhysicalDevice, Dispatch>( *this, d ) ) );
22925 }
22926 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
22927 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
22928
22929 //=== VK_EXT_private_data ===
22930
22931 // wrapper function for command vkCreatePrivateDataSlotEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePrivateDataSlotEXT.html
22932 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
22933 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createPrivateDataSlotEXT( const PrivateDataSlotCreateInfo * pCreateInfo,
22934 const AllocationCallbacks * pAllocator,
22935 PrivateDataSlot * pPrivateDataSlot,
22936 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
22937 {
22938 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
22939 return static_cast<Result>( d.vkCreatePrivateDataSlotEXT( static_cast<VkDevice>( m_device ),
22940 reinterpret_cast<const VkPrivateDataSlotCreateInfo *>( pCreateInfo ),
22941 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
22942 reinterpret_cast<VkPrivateDataSlot *>( pPrivateDataSlot ) ) );
22943 }
22944
22945 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
22946 // wrapper function for command vkCreatePrivateDataSlotEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePrivateDataSlotEXT.html
22947 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
22948 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<PrivateDataSlot>::type
22949 Device::createPrivateDataSlotEXT( const PrivateDataSlotCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
22950 {
22951 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
22952 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
22953 VULKAN_HPP_ASSERT( d.vkCreatePrivateDataSlotEXT && "Function <vkCreatePrivateDataSlotEXT> requires <VK_EXT_private_data> or <VK_VERSION_1_3>" );
22954 # endif
22955
22956 PrivateDataSlot privateDataSlot;
22957 Result result = static_cast<Result>( d.vkCreatePrivateDataSlotEXT( m_device,
22958 reinterpret_cast<const VkPrivateDataSlotCreateInfo *>( &createInfo ),
22959 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
22960 reinterpret_cast<VkPrivateDataSlot *>( &privateDataSlot ) ) );
22961 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createPrivateDataSlotEXT" );
22962
22963 return detail::createResultValueType( result, std::move( privateDataSlot ) );
22964 }
22965
22966 # ifndef VULKAN_HPP_NO_SMART_HANDLE
22967 // wrapper function for command vkCreatePrivateDataSlotEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePrivateDataSlotEXT.html
22968 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
22969 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<PrivateDataSlot, Dispatch>>::type Device::createPrivateDataSlotEXTUnique(
22970 const PrivateDataSlotCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
22971 {
22972 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
22973 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
22974 VULKAN_HPP_ASSERT( d.vkCreatePrivateDataSlotEXT && "Function <vkCreatePrivateDataSlotEXT> requires <VK_EXT_private_data> or <VK_VERSION_1_3>" );
22975 # endif
22976
22977 PrivateDataSlot privateDataSlot;
22978 Result result = static_cast<Result>( d.vkCreatePrivateDataSlotEXT( m_device,
22979 reinterpret_cast<const VkPrivateDataSlotCreateInfo *>( &createInfo ),
22980 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
22981 reinterpret_cast<VkPrivateDataSlot *>( &privateDataSlot ) ) );
22982 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createPrivateDataSlotEXTUnique" );
22983
22984 return detail::createResultValueType(
22985 result, UniqueHandle<PrivateDataSlot, Dispatch>( privateDataSlot, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
22986 }
22987 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
22988 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
22989
22990 // wrapper function for command vkDestroyPrivateDataSlotEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPrivateDataSlotEXT.html
22991 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
22992 VULKAN_HPP_INLINE void
22993 Device::destroyPrivateDataSlotEXT( PrivateDataSlot privateDataSlot, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
22994 {
22995 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
22996 d.vkDestroyPrivateDataSlotEXT(
22997 static_cast<VkDevice>( m_device ), static_cast<VkPrivateDataSlot>( privateDataSlot ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
22998 }
22999
23000 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
23001 // wrapper function for command vkDestroyPrivateDataSlotEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPrivateDataSlotEXT.html
23002 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
23003 VULKAN_HPP_INLINE void Device::destroyPrivateDataSlotEXT( PrivateDataSlot privateDataSlot,
23004 Optional<const AllocationCallbacks> allocator,
23005 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
23006 {
23007 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
23008 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
23009 VULKAN_HPP_ASSERT( d.vkDestroyPrivateDataSlotEXT && "Function <vkDestroyPrivateDataSlotEXT> requires <VK_EXT_private_data> or <VK_VERSION_1_3>" );
23010 # endif
23011
23012 d.vkDestroyPrivateDataSlotEXT(
23013 m_device, static_cast<VkPrivateDataSlot>( privateDataSlot ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
23014 }
23015 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
23016
23017 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
23018 // wrapper function for command vkSetPrivateDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetPrivateDataEXT.html
23019 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
23020 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::setPrivateDataEXT(
23021 ObjectType objectType_, uint64_t objectHandle, PrivateDataSlot privateDataSlot, uint64_t data, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
23022 {
23023 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
23024 return static_cast<Result>( d.vkSetPrivateDataEXT(
23025 static_cast<VkDevice>( m_device ), static_cast<VkObjectType>( objectType_ ), objectHandle, static_cast<VkPrivateDataSlot>( privateDataSlot ), data ) );
23026 }
23027 #else
23028 // wrapper function for command vkSetPrivateDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetPrivateDataEXT.html
23029 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
23030 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
23031 Device::setPrivateDataEXT( ObjectType objectType_, uint64_t objectHandle, PrivateDataSlot privateDataSlot, uint64_t data, Dispatch const & d ) const
23032 {
23033 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
23034 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
23035 VULKAN_HPP_ASSERT( d.vkSetPrivateDataEXT && "Function <vkSetPrivateDataEXT> requires <VK_EXT_private_data> or <VK_VERSION_1_3>" );
23036 # endif
23037
23038 Result result = static_cast<Result>(
23039 d.vkSetPrivateDataEXT( m_device, static_cast<VkObjectType>( objectType_ ), objectHandle, static_cast<VkPrivateDataSlot>( privateDataSlot ), data ) );
23040 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setPrivateDataEXT" );
23041
23042 return detail::createResultValueType( result );
23043 }
23044 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
23045
23046 // wrapper function for command vkGetPrivateDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPrivateDataEXT.html
23047 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
23048 VULKAN_HPP_INLINE void Device::getPrivateDataEXT(
23049 ObjectType objectType_, uint64_t objectHandle, PrivateDataSlot privateDataSlot, uint64_t * pData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
23050 {
23051 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
23052 d.vkGetPrivateDataEXT(
23053 static_cast<VkDevice>( m_device ), static_cast<VkObjectType>( objectType_ ), objectHandle, static_cast<VkPrivateDataSlot>( privateDataSlot ), pData );
23054 }
23055
23056 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
23057 // wrapper function for command vkGetPrivateDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPrivateDataEXT.html
23058 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
23059 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t
23060 Device::getPrivateDataEXT( ObjectType objectType_, uint64_t objectHandle, PrivateDataSlot privateDataSlot, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
23061 {
23062 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
23063 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
23064 VULKAN_HPP_ASSERT( d.vkGetPrivateDataEXT && "Function <vkGetPrivateDataEXT> requires <VK_EXT_private_data> or <VK_VERSION_1_3>" );
23065 # endif
23066
23067 uint64_t data;
23068 d.vkGetPrivateDataEXT( m_device, static_cast<VkObjectType>( objectType_ ), objectHandle, static_cast<VkPrivateDataSlot>( privateDataSlot ), &data );
23069
23070 return data;
23071 }
23072 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
23073
23074 //=== VK_KHR_video_encode_queue ===
23075
23076 // wrapper function for command vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR, see
23077 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR.html
23078 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
23079 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
23080 PhysicalDevice::getVideoEncodeQualityLevelPropertiesKHR( const PhysicalDeviceVideoEncodeQualityLevelInfoKHR * pQualityLevelInfo,
23081 VideoEncodeQualityLevelPropertiesKHR * pQualityLevelProperties,
23082 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
23083 {
23084 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
23085 return static_cast<Result>(
23086 d.vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
23087 reinterpret_cast<const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR *>( pQualityLevelInfo ),
23088 reinterpret_cast<VkVideoEncodeQualityLevelPropertiesKHR *>( pQualityLevelProperties ) ) );
23089 }
23090
23091 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
23092 // wrapper function for command vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR, see
23093 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR.html
23094 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
23095 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VideoEncodeQualityLevelPropertiesKHR>::type
23096 PhysicalDevice::getVideoEncodeQualityLevelPropertiesKHR( const PhysicalDeviceVideoEncodeQualityLevelInfoKHR & qualityLevelInfo, Dispatch const & d ) const
23097 {
23098 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
23099 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
23100 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR &&
23101 "Function <vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR> requires <VK_KHR_video_encode_queue>" );
23102 # endif
23103
23104 VideoEncodeQualityLevelPropertiesKHR qualityLevelProperties;
23105 Result result = static_cast<Result>(
23106 d.vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( m_physicalDevice,
23107 reinterpret_cast<const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR *>( &qualityLevelInfo ),
23108 reinterpret_cast<VkVideoEncodeQualityLevelPropertiesKHR *>( &qualityLevelProperties ) ) );
23109 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoEncodeQualityLevelPropertiesKHR" );
23110
23111 return detail::createResultValueType( result, std::move( qualityLevelProperties ) );
23112 }
23113
23114 // wrapper function for command vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR, see
23115 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR.html
23116 template <typename X, typename Y, typename... Z, typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
23117 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<StructureChain<X, Y, Z...>>::type
23118 PhysicalDevice::getVideoEncodeQualityLevelPropertiesKHR( const PhysicalDeviceVideoEncodeQualityLevelInfoKHR & qualityLevelInfo, Dispatch const & d ) const
23119 {
23120 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
23121 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
23122 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR &&
23123 "Function <vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR> requires <VK_KHR_video_encode_queue>" );
23124 # endif
23125
23126 StructureChain<X, Y, Z...> structureChain;
23127 VideoEncodeQualityLevelPropertiesKHR & qualityLevelProperties = structureChain.template get<VideoEncodeQualityLevelPropertiesKHR>();
23128 Result result = static_cast<Result>(
23129 d.vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( m_physicalDevice,
23130 reinterpret_cast<const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR *>( &qualityLevelInfo ),
23131 reinterpret_cast<VkVideoEncodeQualityLevelPropertiesKHR *>( &qualityLevelProperties ) ) );
23132 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoEncodeQualityLevelPropertiesKHR" );
23133
23134 return detail::createResultValueType( result, std::move( structureChain ) );
23135 }
23136 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
23137
23138 // wrapper function for command vkGetEncodedVideoSessionParametersKHR, see
23139 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEncodedVideoSessionParametersKHR.html
23140 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
23141 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
23142 Device::getEncodedVideoSessionParametersKHR( const VideoEncodeSessionParametersGetInfoKHR * pVideoSessionParametersInfo,
23143 VideoEncodeSessionParametersFeedbackInfoKHR * pFeedbackInfo,
23144 size_t * pDataSize,
23145 void * pData,
23146 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
23147 {
23148 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
23149 return static_cast<Result>(
23150 d.vkGetEncodedVideoSessionParametersKHR( static_cast<VkDevice>( m_device ),
23151 reinterpret_cast<const VkVideoEncodeSessionParametersGetInfoKHR *>( pVideoSessionParametersInfo ),
23152 reinterpret_cast<VkVideoEncodeSessionParametersFeedbackInfoKHR *>( pFeedbackInfo ),
23153 pDataSize,
23154 pData ) );
23155 }
23156
23157 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
23158 // wrapper function for command vkGetEncodedVideoSessionParametersKHR, see
23159 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEncodedVideoSessionParametersKHR.html
23160 template <typename Uint8_tAllocator,
23161 typename Dispatch,
23162 typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type,
23163 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
23164 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
23165 typename ResultValueType<std::pair<VideoEncodeSessionParametersFeedbackInfoKHR, std::vector<uint8_t, Uint8_tAllocator>>>::type
23166 Device::getEncodedVideoSessionParametersKHR( const VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo, Dispatch const & d ) const
23167 {
23168 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
23169 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
23170 VULKAN_HPP_ASSERT( d.vkGetEncodedVideoSessionParametersKHR && "Function <vkGetEncodedVideoSessionParametersKHR> requires <VK_KHR_video_encode_queue>" );
23171 # endif
23172
23173 std::pair<VideoEncodeSessionParametersFeedbackInfoKHR, std::vector<uint8_t, Uint8_tAllocator>> data_;
23174 VideoEncodeSessionParametersFeedbackInfoKHR & feedbackInfo = data_.first;
23175 std::vector<uint8_t, Uint8_tAllocator> & data = data_.second;
23176 size_t dataSize;
23177 Result result;
23178 do
23179 {
23180 result = static_cast<Result>(
23181 d.vkGetEncodedVideoSessionParametersKHR( m_device,
23182 reinterpret_cast<const VkVideoEncodeSessionParametersGetInfoKHR *>( &videoSessionParametersInfo ),
23183 reinterpret_cast<VkVideoEncodeSessionParametersFeedbackInfoKHR *>( &feedbackInfo ),
23184 &dataSize,
23185 nullptr ) );
23186 if ( ( result == Result::eSuccess ) && dataSize )
23187 {
23188 data.resize( dataSize );
23189 result = static_cast<Result>(
23190 d.vkGetEncodedVideoSessionParametersKHR( m_device,
23191 reinterpret_cast<const VkVideoEncodeSessionParametersGetInfoKHR *>( &videoSessionParametersInfo ),
23192 reinterpret_cast<VkVideoEncodeSessionParametersFeedbackInfoKHR *>( &feedbackInfo ),
23193 &dataSize,
23194 reinterpret_cast<void *>( data.data() ) ) );
23195 }
23196 } while ( result == Result::eIncomplete );
23197 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getEncodedVideoSessionParametersKHR" );
23198
23199 return detail::createResultValueType( result, std::move( data_ ) );
23200 }
23201
23202 // wrapper function for command vkGetEncodedVideoSessionParametersKHR, see
23203 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEncodedVideoSessionParametersKHR.html
23204 template <typename Uint8_tAllocator,
23205 typename Dispatch,
23206 typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type,
23207 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
23208 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
23209 typename ResultValueType<std::pair<VideoEncodeSessionParametersFeedbackInfoKHR, std::vector<uint8_t, Uint8_tAllocator>>>::type
23210 Device::getEncodedVideoSessionParametersKHR( const VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo,
23211 Uint8_tAllocator & uint8_tAllocator,
23212 Dispatch const & d ) const
23213 {
23214 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
23215 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
23216 VULKAN_HPP_ASSERT( d.vkGetEncodedVideoSessionParametersKHR && "Function <vkGetEncodedVideoSessionParametersKHR> requires <VK_KHR_video_encode_queue>" );
23217 # endif
23218
23219 std::pair<VideoEncodeSessionParametersFeedbackInfoKHR, std::vector<uint8_t, Uint8_tAllocator>> data_(
23220 std::piecewise_construct, std::forward_as_tuple(), std::forward_as_tuple( uint8_tAllocator ) );
23221 VideoEncodeSessionParametersFeedbackInfoKHR & feedbackInfo = data_.first;
23222 std::vector<uint8_t, Uint8_tAllocator> & data = data_.second;
23223 size_t dataSize;
23224 Result result;
23225 do
23226 {
23227 result = static_cast<Result>(
23228 d.vkGetEncodedVideoSessionParametersKHR( m_device,
23229 reinterpret_cast<const VkVideoEncodeSessionParametersGetInfoKHR *>( &videoSessionParametersInfo ),
23230 reinterpret_cast<VkVideoEncodeSessionParametersFeedbackInfoKHR *>( &feedbackInfo ),
23231 &dataSize,
23232 nullptr ) );
23233 if ( ( result == Result::eSuccess ) && dataSize )
23234 {
23235 data.resize( dataSize );
23236 result = static_cast<Result>(
23237 d.vkGetEncodedVideoSessionParametersKHR( m_device,
23238 reinterpret_cast<const VkVideoEncodeSessionParametersGetInfoKHR *>( &videoSessionParametersInfo ),
23239 reinterpret_cast<VkVideoEncodeSessionParametersFeedbackInfoKHR *>( &feedbackInfo ),
23240 &dataSize,
23241 reinterpret_cast<void *>( data.data() ) ) );
23242 }
23243 } while ( result == Result::eIncomplete );
23244 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getEncodedVideoSessionParametersKHR" );
23245
23246 return detail::createResultValueType( result, std::move( data_ ) );
23247 }
23248
23249 // wrapper function for command vkGetEncodedVideoSessionParametersKHR, see
23250 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEncodedVideoSessionParametersKHR.html
23251 template <typename X,
23252 typename Y,
23253 typename... Z,
23254 typename Uint8_tAllocator,
23255 typename Dispatch,
23256 typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type,
23257 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
23258 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::pair<StructureChain<X, Y, Z...>, std::vector<uint8_t, Uint8_tAllocator>>>::type
23259 Device::getEncodedVideoSessionParametersKHR( const VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo, Dispatch const & d ) const
23260 {
23261 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
23262 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
23263 VULKAN_HPP_ASSERT( d.vkGetEncodedVideoSessionParametersKHR && "Function <vkGetEncodedVideoSessionParametersKHR> requires <VK_KHR_video_encode_queue>" );
23264 # endif
23265
23266 std::pair<StructureChain<X, Y, Z...>, std::vector<uint8_t, Uint8_tAllocator>> data_;
23267 VideoEncodeSessionParametersFeedbackInfoKHR & feedbackInfo = data_.first.template get<VideoEncodeSessionParametersFeedbackInfoKHR>();
23268 std::vector<uint8_t, Uint8_tAllocator> & data = data_.second;
23269 size_t dataSize;
23270 Result result;
23271 do
23272 {
23273 result = static_cast<Result>(
23274 d.vkGetEncodedVideoSessionParametersKHR( m_device,
23275 reinterpret_cast<const VkVideoEncodeSessionParametersGetInfoKHR *>( &videoSessionParametersInfo ),
23276 reinterpret_cast<VkVideoEncodeSessionParametersFeedbackInfoKHR *>( &feedbackInfo ),
23277 &dataSize,
23278 nullptr ) );
23279 if ( ( result == Result::eSuccess ) && dataSize )
23280 {
23281 data.resize( dataSize );
23282 result = static_cast<Result>(
23283 d.vkGetEncodedVideoSessionParametersKHR( m_device,
23284 reinterpret_cast<const VkVideoEncodeSessionParametersGetInfoKHR *>( &videoSessionParametersInfo ),
23285 reinterpret_cast<VkVideoEncodeSessionParametersFeedbackInfoKHR *>( &feedbackInfo ),
23286 &dataSize,
23287 reinterpret_cast<void *>( data.data() ) ) );
23288 }
23289 } while ( result == Result::eIncomplete );
23290 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getEncodedVideoSessionParametersKHR" );
23291
23292 return detail::createResultValueType( result, std::move( data_ ) );
23293 }
23294
23295 // wrapper function for command vkGetEncodedVideoSessionParametersKHR, see
23296 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEncodedVideoSessionParametersKHR.html
23297 template <typename X,
23298 typename Y,
23299 typename... Z,
23300 typename Uint8_tAllocator,
23301 typename Dispatch,
23302 typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type,
23303 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
23304 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::pair<StructureChain<X, Y, Z...>, std::vector<uint8_t, Uint8_tAllocator>>>::type
23305 Device::getEncodedVideoSessionParametersKHR( const VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo,
23306 Uint8_tAllocator & uint8_tAllocator,
23307 Dispatch const & d ) const
23308 {
23309 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
23310 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
23311 VULKAN_HPP_ASSERT( d.vkGetEncodedVideoSessionParametersKHR && "Function <vkGetEncodedVideoSessionParametersKHR> requires <VK_KHR_video_encode_queue>" );
23312 # endif
23313
23314 std::pair<StructureChain<X, Y, Z...>, std::vector<uint8_t, Uint8_tAllocator>> data_(
23315 std::piecewise_construct, std::forward_as_tuple(), std::forward_as_tuple( uint8_tAllocator ) );
23316 VideoEncodeSessionParametersFeedbackInfoKHR & feedbackInfo = data_.first.template get<VideoEncodeSessionParametersFeedbackInfoKHR>();
23317 std::vector<uint8_t, Uint8_tAllocator> & data = data_.second;
23318 size_t dataSize;
23319 Result result;
23320 do
23321 {
23322 result = static_cast<Result>(
23323 d.vkGetEncodedVideoSessionParametersKHR( m_device,
23324 reinterpret_cast<const VkVideoEncodeSessionParametersGetInfoKHR *>( &videoSessionParametersInfo ),
23325 reinterpret_cast<VkVideoEncodeSessionParametersFeedbackInfoKHR *>( &feedbackInfo ),
23326 &dataSize,
23327 nullptr ) );
23328 if ( ( result == Result::eSuccess ) && dataSize )
23329 {
23330 data.resize( dataSize );
23331 result = static_cast<Result>(
23332 d.vkGetEncodedVideoSessionParametersKHR( m_device,
23333 reinterpret_cast<const VkVideoEncodeSessionParametersGetInfoKHR *>( &videoSessionParametersInfo ),
23334 reinterpret_cast<VkVideoEncodeSessionParametersFeedbackInfoKHR *>( &feedbackInfo ),
23335 &dataSize,
23336 reinterpret_cast<void *>( data.data() ) ) );
23337 }
23338 } while ( result == Result::eIncomplete );
23339 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getEncodedVideoSessionParametersKHR" );
23340
23341 return detail::createResultValueType( result, std::move( data_ ) );
23342 }
23343 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
23344
23345 // wrapper function for command vkCmdEncodeVideoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEncodeVideoKHR.html
23346 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
23347 VULKAN_HPP_INLINE void CommandBuffer::encodeVideoKHR( const VideoEncodeInfoKHR * pEncodeInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
23348 {
23349 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
23350 d.vkCmdEncodeVideoKHR( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkVideoEncodeInfoKHR *>( pEncodeInfo ) );
23351 }
23352
23353 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
23354 // wrapper function for command vkCmdEncodeVideoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEncodeVideoKHR.html
23355 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
23356 VULKAN_HPP_INLINE void CommandBuffer::encodeVideoKHR( const VideoEncodeInfoKHR & encodeInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
23357 {
23358 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
23359 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
23360 VULKAN_HPP_ASSERT( d.vkCmdEncodeVideoKHR && "Function <vkCmdEncodeVideoKHR> requires <VK_KHR_video_encode_queue>" );
23361 # endif
23362
23363 d.vkCmdEncodeVideoKHR( m_commandBuffer, reinterpret_cast<const VkVideoEncodeInfoKHR *>( &encodeInfo ) );
23364 }
23365 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
23366
23367 #if defined( VK_ENABLE_BETA_EXTENSIONS )
23368 //=== VK_NV_cuda_kernel_launch ===
23369
23370 // wrapper function for command vkCreateCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCudaModuleNV.html
23371 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
23372 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createCudaModuleNV( const CudaModuleCreateInfoNV * pCreateInfo,
23373 const AllocationCallbacks * pAllocator,
23374 CudaModuleNV * pModule,
23375 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
23376 {
23377 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
23378 return static_cast<Result>( d.vkCreateCudaModuleNV( static_cast<VkDevice>( m_device ),
23379 reinterpret_cast<const VkCudaModuleCreateInfoNV *>( pCreateInfo ),
23380 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
23381 reinterpret_cast<VkCudaModuleNV *>( pModule ) ) );
23382 }
23383
23384 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
23385 // wrapper function for command vkCreateCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCudaModuleNV.html
23386 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
23387 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<CudaModuleNV>::type
23388 Device::createCudaModuleNV( const CudaModuleCreateInfoNV & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
23389 {
23390 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
23391 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
23392 VULKAN_HPP_ASSERT( d.vkCreateCudaModuleNV && "Function <vkCreateCudaModuleNV> requires <VK_NV_cuda_kernel_launch>" );
23393 # endif
23394
23395 CudaModuleNV module;
23396 Result result = static_cast<Result>( d.vkCreateCudaModuleNV( m_device,
23397 reinterpret_cast<const VkCudaModuleCreateInfoNV *>( &createInfo ),
23398 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
23399 reinterpret_cast<VkCudaModuleNV *>( &module ) ) );
23400 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createCudaModuleNV" );
23401
23402 return detail::createResultValueType( result, std::move( module ) );
23403 }
23404
23405 # ifndef VULKAN_HPP_NO_SMART_HANDLE
23406 // wrapper function for command vkCreateCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCudaModuleNV.html
23407 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
23408 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<CudaModuleNV, Dispatch>>::type
23409 Device::createCudaModuleNVUnique( const CudaModuleCreateInfoNV & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
23410 {
23411 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
23412 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
23413 VULKAN_HPP_ASSERT( d.vkCreateCudaModuleNV && "Function <vkCreateCudaModuleNV> requires <VK_NV_cuda_kernel_launch>" );
23414 # endif
23415
23416 CudaModuleNV module;
23417 Result result = static_cast<Result>( d.vkCreateCudaModuleNV( m_device,
23418 reinterpret_cast<const VkCudaModuleCreateInfoNV *>( &createInfo ),
23419 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
23420 reinterpret_cast<VkCudaModuleNV *>( &module ) ) );
23421 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createCudaModuleNVUnique" );
23422
23423 return detail::createResultValueType( result,
23424 UniqueHandle<CudaModuleNV, Dispatch>( module, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
23425 }
23426 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
23427 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
23428
23429 // wrapper function for command vkGetCudaModuleCacheNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCudaModuleCacheNV.html
23430 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
23431 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
23432 Device::getCudaModuleCacheNV( CudaModuleNV module, size_t * pCacheSize, void * pCacheData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
23433 {
23434 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
23435 return static_cast<Result>( d.vkGetCudaModuleCacheNV( static_cast<VkDevice>( m_device ), static_cast<VkCudaModuleNV>( module ), pCacheSize, pCacheData ) );
23436 }
23437
23438 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
23439 // wrapper function for command vkGetCudaModuleCacheNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCudaModuleCacheNV.html
23440 template <typename Uint8_tAllocator,
23441 typename Dispatch,
23442 typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type,
23443 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
23444 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
23445 Device::getCudaModuleCacheNV( CudaModuleNV module, Dispatch const & d ) const
23446 {
23447 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
23448 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
23449 VULKAN_HPP_ASSERT( d.vkGetCudaModuleCacheNV && "Function <vkGetCudaModuleCacheNV> requires <VK_NV_cuda_kernel_launch>" );
23450 # endif
23451
23452 std::vector<uint8_t, Uint8_tAllocator> cacheData;
23453 size_t cacheSize;
23454 Result result;
23455 do
23456 {
23457 result = static_cast<Result>( d.vkGetCudaModuleCacheNV( m_device, static_cast<VkCudaModuleNV>( module ), &cacheSize, nullptr ) );
23458 if ( ( result == Result::eSuccess ) && cacheSize )
23459 {
23460 cacheData.resize( cacheSize );
23461 result = static_cast<Result>(
23462 d.vkGetCudaModuleCacheNV( m_device, static_cast<VkCudaModuleNV>( module ), &cacheSize, reinterpret_cast<void *>( cacheData.data() ) ) );
23463 }
23464 } while ( result == Result::eIncomplete );
23465 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getCudaModuleCacheNV" );
23466 VULKAN_HPP_ASSERT( cacheSize <= cacheData.size() );
23467 if ( cacheSize < cacheData.size() )
23468 {
23469 cacheData.resize( cacheSize );
23470 }
23471 return detail::createResultValueType( result, std::move( cacheData ) );
23472 }
23473
23474 // wrapper function for command vkGetCudaModuleCacheNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCudaModuleCacheNV.html
23475 template <typename Uint8_tAllocator,
23476 typename Dispatch,
23477 typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type,
23478 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
23479 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
23480 Device::getCudaModuleCacheNV( CudaModuleNV module, Uint8_tAllocator & uint8_tAllocator, Dispatch const & d ) const
23481 {
23482 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
23483 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
23484 VULKAN_HPP_ASSERT( d.vkGetCudaModuleCacheNV && "Function <vkGetCudaModuleCacheNV> requires <VK_NV_cuda_kernel_launch>" );
23485 # endif
23486
23487 std::vector<uint8_t, Uint8_tAllocator> cacheData( uint8_tAllocator );
23488 size_t cacheSize;
23489 Result result;
23490 do
23491 {
23492 result = static_cast<Result>( d.vkGetCudaModuleCacheNV( m_device, static_cast<VkCudaModuleNV>( module ), &cacheSize, nullptr ) );
23493 if ( ( result == Result::eSuccess ) && cacheSize )
23494 {
23495 cacheData.resize( cacheSize );
23496 result = static_cast<Result>(
23497 d.vkGetCudaModuleCacheNV( m_device, static_cast<VkCudaModuleNV>( module ), &cacheSize, reinterpret_cast<void *>( cacheData.data() ) ) );
23498 }
23499 } while ( result == Result::eIncomplete );
23500 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getCudaModuleCacheNV" );
23501 VULKAN_HPP_ASSERT( cacheSize <= cacheData.size() );
23502 if ( cacheSize < cacheData.size() )
23503 {
23504 cacheData.resize( cacheSize );
23505 }
23506 return detail::createResultValueType( result, std::move( cacheData ) );
23507 }
23508 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
23509
23510 // wrapper function for command vkCreateCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCudaFunctionNV.html
23511 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
23512 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createCudaFunctionNV( const CudaFunctionCreateInfoNV * pCreateInfo,
23513 const AllocationCallbacks * pAllocator,
23514 CudaFunctionNV * pFunction,
23515 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
23516 {
23517 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
23518 return static_cast<Result>( d.vkCreateCudaFunctionNV( static_cast<VkDevice>( m_device ),
23519 reinterpret_cast<const VkCudaFunctionCreateInfoNV *>( pCreateInfo ),
23520 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
23521 reinterpret_cast<VkCudaFunctionNV *>( pFunction ) ) );
23522 }
23523
23524 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
23525 // wrapper function for command vkCreateCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCudaFunctionNV.html
23526 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
23527 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<CudaFunctionNV>::type
23528 Device::createCudaFunctionNV( const CudaFunctionCreateInfoNV & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
23529 {
23530 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
23531 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
23532 VULKAN_HPP_ASSERT( d.vkCreateCudaFunctionNV && "Function <vkCreateCudaFunctionNV> requires <VK_NV_cuda_kernel_launch>" );
23533 # endif
23534
23535 CudaFunctionNV function;
23536 Result result = static_cast<Result>( d.vkCreateCudaFunctionNV( m_device,
23537 reinterpret_cast<const VkCudaFunctionCreateInfoNV *>( &createInfo ),
23538 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
23539 reinterpret_cast<VkCudaFunctionNV *>( &function ) ) );
23540 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createCudaFunctionNV" );
23541
23542 return detail::createResultValueType( result, std::move( function ) );
23543 }
23544
23545 # ifndef VULKAN_HPP_NO_SMART_HANDLE
23546 // wrapper function for command vkCreateCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCudaFunctionNV.html
23547 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
23548 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<CudaFunctionNV, Dispatch>>::type
23549 Device::createCudaFunctionNVUnique( const CudaFunctionCreateInfoNV & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
23550 {
23551 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
23552 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
23553 VULKAN_HPP_ASSERT( d.vkCreateCudaFunctionNV && "Function <vkCreateCudaFunctionNV> requires <VK_NV_cuda_kernel_launch>" );
23554 # endif
23555
23556 CudaFunctionNV function;
23557 Result result = static_cast<Result>( d.vkCreateCudaFunctionNV( m_device,
23558 reinterpret_cast<const VkCudaFunctionCreateInfoNV *>( &createInfo ),
23559 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
23560 reinterpret_cast<VkCudaFunctionNV *>( &function ) ) );
23561 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createCudaFunctionNVUnique" );
23562
23563 return detail::createResultValueType( result,
23564 UniqueHandle<CudaFunctionNV, Dispatch>( function, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
23565 }
23566 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
23567 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
23568
23569 // wrapper function for command vkDestroyCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCudaModuleNV.html
23570 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
23571 VULKAN_HPP_INLINE void
23572 Device::destroyCudaModuleNV( CudaModuleNV module, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
23573 {
23574 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
23575 d.vkDestroyCudaModuleNV(
23576 static_cast<VkDevice>( m_device ), static_cast<VkCudaModuleNV>( module ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
23577 }
23578
23579 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
23580 // wrapper function for command vkDestroyCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCudaModuleNV.html
23581 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
23582 VULKAN_HPP_INLINE void
23583 Device::destroyCudaModuleNV( CudaModuleNV module, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
23584 {
23585 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
23586 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
23587 VULKAN_HPP_ASSERT( d.vkDestroyCudaModuleNV && "Function <vkDestroyCudaModuleNV> requires <VK_NV_cuda_kernel_launch>" );
23588 # endif
23589
23590 d.vkDestroyCudaModuleNV( m_device, static_cast<VkCudaModuleNV>( module ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
23591 }
23592 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
23593
23594 // wrapper function for command vkDestroyCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCudaModuleNV.html
23595 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
23596 VULKAN_HPP_INLINE void Device::destroy( CudaModuleNV module, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
23597 {
23598 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
23599 d.vkDestroyCudaModuleNV(
23600 static_cast<VkDevice>( m_device ), static_cast<VkCudaModuleNV>( module ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
23601 }
23602
23603 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
23604 // wrapper function for command vkDestroyCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCudaModuleNV.html
23605 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
23606 VULKAN_HPP_INLINE void Device::destroy( CudaModuleNV module, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
23607 {
23608 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
23609 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
23610 VULKAN_HPP_ASSERT( d.vkDestroyCudaModuleNV && "Function <vkDestroyCudaModuleNV> requires <VK_NV_cuda_kernel_launch>" );
23611 # endif
23612
23613 d.vkDestroyCudaModuleNV( m_device, static_cast<VkCudaModuleNV>( module ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
23614 }
23615 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
23616
23617 // wrapper function for command vkDestroyCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCudaFunctionNV.html
23618 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
23619 VULKAN_HPP_INLINE void
23620 Device::destroyCudaFunctionNV( CudaFunctionNV function, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
23621 {
23622 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
23623 d.vkDestroyCudaFunctionNV(
23624 static_cast<VkDevice>( m_device ), static_cast<VkCudaFunctionNV>( function ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
23625 }
23626
23627 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
23628 // wrapper function for command vkDestroyCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCudaFunctionNV.html
23629 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
23630 VULKAN_HPP_INLINE void
23631 Device::destroyCudaFunctionNV( CudaFunctionNV function, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
23632 {
23633 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
23634 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
23635 VULKAN_HPP_ASSERT( d.vkDestroyCudaFunctionNV && "Function <vkDestroyCudaFunctionNV> requires <VK_NV_cuda_kernel_launch>" );
23636 # endif
23637
23638 d.vkDestroyCudaFunctionNV( m_device, static_cast<VkCudaFunctionNV>( function ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
23639 }
23640 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
23641
23642 // wrapper function for command vkDestroyCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCudaFunctionNV.html
23643 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
23644 VULKAN_HPP_INLINE void Device::destroy( CudaFunctionNV function, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
23645 {
23646 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
23647 d.vkDestroyCudaFunctionNV(
23648 static_cast<VkDevice>( m_device ), static_cast<VkCudaFunctionNV>( function ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
23649 }
23650
23651 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
23652 // wrapper function for command vkDestroyCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCudaFunctionNV.html
23653 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
23654 VULKAN_HPP_INLINE void Device::destroy( CudaFunctionNV function, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
23655 {
23656 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
23657 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
23658 VULKAN_HPP_ASSERT( d.vkDestroyCudaFunctionNV && "Function <vkDestroyCudaFunctionNV> requires <VK_NV_cuda_kernel_launch>" );
23659 # endif
23660
23661 d.vkDestroyCudaFunctionNV( m_device, static_cast<VkCudaFunctionNV>( function ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
23662 }
23663 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
23664
23665 // wrapper function for command vkCmdCudaLaunchKernelNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCudaLaunchKernelNV.html
23666 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
23667 VULKAN_HPP_INLINE void CommandBuffer::cudaLaunchKernelNV( const CudaLaunchInfoNV * pLaunchInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
23668 {
23669 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
23670 d.vkCmdCudaLaunchKernelNV( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkCudaLaunchInfoNV *>( pLaunchInfo ) );
23671 }
23672
23673 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
23674 // wrapper function for command vkCmdCudaLaunchKernelNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCudaLaunchKernelNV.html
23675 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
23676 VULKAN_HPP_INLINE void CommandBuffer::cudaLaunchKernelNV( const CudaLaunchInfoNV & launchInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
23677 {
23678 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
23679 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
23680 VULKAN_HPP_ASSERT( d.vkCmdCudaLaunchKernelNV && "Function <vkCmdCudaLaunchKernelNV> requires <VK_NV_cuda_kernel_launch>" );
23681 # endif
23682
23683 d.vkCmdCudaLaunchKernelNV( m_commandBuffer, reinterpret_cast<const VkCudaLaunchInfoNV *>( &launchInfo ) );
23684 }
23685 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
23686 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
23687
23688 //=== VK_QCOM_tile_shading ===
23689
23690 // wrapper function for command vkCmdDispatchTileQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchTileQCOM.html
23691 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
23692 VULKAN_HPP_INLINE void CommandBuffer::dispatchTileQCOM( const DispatchTileInfoQCOM * pDispatchTileInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
23693 {
23694 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
23695 d.vkCmdDispatchTileQCOM( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkDispatchTileInfoQCOM *>( pDispatchTileInfo ) );
23696 }
23697
23698 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
23699 // wrapper function for command vkCmdDispatchTileQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchTileQCOM.html
23700 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
23701 VULKAN_HPP_INLINE void CommandBuffer::dispatchTileQCOM( const DispatchTileInfoQCOM & dispatchTileInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
23702 {
23703 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
23704 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
23705 VULKAN_HPP_ASSERT( d.vkCmdDispatchTileQCOM && "Function <vkCmdDispatchTileQCOM> requires <VK_QCOM_tile_shading>" );
23706 # endif
23707
23708 d.vkCmdDispatchTileQCOM( m_commandBuffer, reinterpret_cast<const VkDispatchTileInfoQCOM *>( &dispatchTileInfo ) );
23709 }
23710 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
23711
23712 // wrapper function for command vkCmdBeginPerTileExecutionQCOM, see
23713 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginPerTileExecutionQCOM.html
23714 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
23715 VULKAN_HPP_INLINE void CommandBuffer::beginPerTileExecutionQCOM( const PerTileBeginInfoQCOM * pPerTileBeginInfo,
23716 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
23717 {
23718 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
23719 d.vkCmdBeginPerTileExecutionQCOM( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkPerTileBeginInfoQCOM *>( pPerTileBeginInfo ) );
23720 }
23721
23722 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
23723 // wrapper function for command vkCmdBeginPerTileExecutionQCOM, see
23724 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginPerTileExecutionQCOM.html
23725 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
23726 VULKAN_HPP_INLINE void CommandBuffer::beginPerTileExecutionQCOM( const PerTileBeginInfoQCOM & perTileBeginInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
23727 {
23728 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
23729 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
23730 VULKAN_HPP_ASSERT( d.vkCmdBeginPerTileExecutionQCOM && "Function <vkCmdBeginPerTileExecutionQCOM> requires <VK_QCOM_tile_shading>" );
23731 # endif
23732
23733 d.vkCmdBeginPerTileExecutionQCOM( m_commandBuffer, reinterpret_cast<const VkPerTileBeginInfoQCOM *>( &perTileBeginInfo ) );
23734 }
23735 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
23736
23737 // wrapper function for command vkCmdEndPerTileExecutionQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndPerTileExecutionQCOM.html
23738 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
23739 VULKAN_HPP_INLINE void CommandBuffer::endPerTileExecutionQCOM( const PerTileEndInfoQCOM * pPerTileEndInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
23740 {
23741 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
23742 d.vkCmdEndPerTileExecutionQCOM( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkPerTileEndInfoQCOM *>( pPerTileEndInfo ) );
23743 }
23744
23745 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
23746 // wrapper function for command vkCmdEndPerTileExecutionQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndPerTileExecutionQCOM.html
23747 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
23748 VULKAN_HPP_INLINE void CommandBuffer::endPerTileExecutionQCOM( const PerTileEndInfoQCOM & perTileEndInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
23749 {
23750 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
23751 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
23752 VULKAN_HPP_ASSERT( d.vkCmdEndPerTileExecutionQCOM && "Function <vkCmdEndPerTileExecutionQCOM> requires <VK_QCOM_tile_shading>" );
23753 # endif
23754
23755 d.vkCmdEndPerTileExecutionQCOM( m_commandBuffer, reinterpret_cast<const VkPerTileEndInfoQCOM *>( &perTileEndInfo ) );
23756 }
23757 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
23758
23759 #if defined( VK_USE_PLATFORM_METAL_EXT )
23760 //=== VK_EXT_metal_objects ===
23761
23762 // wrapper function for command vkExportMetalObjectsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkExportMetalObjectsEXT.html
23763 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
23764 VULKAN_HPP_INLINE void Device::exportMetalObjectsEXT( ExportMetalObjectsInfoEXT * pMetalObjectsInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
23765 {
23766 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
23767 d.vkExportMetalObjectsEXT( static_cast<VkDevice>( m_device ), reinterpret_cast<VkExportMetalObjectsInfoEXT *>( pMetalObjectsInfo ) );
23768 }
23769
23770 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
23771 // wrapper function for command vkExportMetalObjectsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkExportMetalObjectsEXT.html
23772 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
23773 VULKAN_HPP_INLINE void Device::exportMetalObjectsEXT( ExportMetalObjectsInfoEXT & metalObjectsInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
23774 {
23775 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
23776 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
23777 VULKAN_HPP_ASSERT( d.vkExportMetalObjectsEXT && "Function <vkExportMetalObjectsEXT> requires <VK_EXT_metal_objects>" );
23778 # endif
23779
23780 d.vkExportMetalObjectsEXT( m_device, reinterpret_cast<VkExportMetalObjectsInfoEXT *>( &metalObjectsInfo ) );
23781 }
23782 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
23783 #endif /*VK_USE_PLATFORM_METAL_EXT*/
23784
23785 //=== VK_KHR_synchronization2 ===
23786
23787 // wrapper function for command vkCmdSetEvent2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetEvent2KHR.html
23788 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
23789 VULKAN_HPP_INLINE void CommandBuffer::setEvent2KHR( Event event, const DependencyInfo * pDependencyInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
23790 {
23791 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
23792 d.vkCmdSetEvent2KHR(
23793 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkEvent>( event ), reinterpret_cast<const VkDependencyInfo *>( pDependencyInfo ) );
23794 }
23795
23796 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
23797 // wrapper function for command vkCmdSetEvent2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetEvent2KHR.html
23798 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
23799 VULKAN_HPP_INLINE void CommandBuffer::setEvent2KHR( Event event, const DependencyInfo & dependencyInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
23800 {
23801 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
23802 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
23803 VULKAN_HPP_ASSERT( d.vkCmdSetEvent2KHR && "Function <vkCmdSetEvent2KHR> requires <VK_KHR_synchronization2> or <VK_VERSION_1_3>" );
23804 # endif
23805
23806 d.vkCmdSetEvent2KHR( m_commandBuffer, static_cast<VkEvent>( event ), reinterpret_cast<const VkDependencyInfo *>( &dependencyInfo ) );
23807 }
23808 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
23809
23810 // wrapper function for command vkCmdResetEvent2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResetEvent2KHR.html
23811 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
23812 VULKAN_HPP_INLINE void CommandBuffer::resetEvent2KHR( Event event, PipelineStageFlags2 stageMask, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
23813 {
23814 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
23815 d.vkCmdResetEvent2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkEvent>( event ), static_cast<VkPipelineStageFlags2>( stageMask ) );
23816 }
23817
23818 // wrapper function for command vkCmdWaitEvents2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWaitEvents2KHR.html
23819 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
23820 VULKAN_HPP_INLINE void CommandBuffer::waitEvents2KHR( uint32_t eventCount,
23821 const Event * pEvents,
23822 const DependencyInfo * pDependencyInfos,
23823 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
23824 {
23825 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
23826 d.vkCmdWaitEvents2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
23827 eventCount,
23828 reinterpret_cast<const VkEvent *>( pEvents ),
23829 reinterpret_cast<const VkDependencyInfo *>( pDependencyInfos ) );
23830 }
23831
23832 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
23833 // wrapper function for command vkCmdWaitEvents2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWaitEvents2KHR.html
23834 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
23835 VULKAN_HPP_INLINE void CommandBuffer::waitEvents2KHR( ArrayProxy<const Event> const & events,
23836 ArrayProxy<const DependencyInfo> const & dependencyInfos,
23837 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
23838 {
23839 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
23840 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
23841 VULKAN_HPP_ASSERT( d.vkCmdWaitEvents2KHR && "Function <vkCmdWaitEvents2KHR> requires <VK_KHR_synchronization2> or <VK_VERSION_1_3>" );
23842 # endif
23843 # ifdef VULKAN_HPP_NO_EXCEPTIONS
23844 VULKAN_HPP_ASSERT( events.size() == dependencyInfos.size() );
23845 # else
23846 if ( events.size() != dependencyInfos.size() )
23847 {
23848 throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::waitEvents2KHR: events.size() != dependencyInfos.size()" );
23849 }
23850 # endif /*VULKAN_HPP_NO_EXCEPTIONS*/
23851
23852 d.vkCmdWaitEvents2KHR( m_commandBuffer,
23853 events.size(),
23854 reinterpret_cast<const VkEvent *>( events.data() ),
23855 reinterpret_cast<const VkDependencyInfo *>( dependencyInfos.data() ) );
23856 }
23857 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
23858
23859 // wrapper function for command vkCmdPipelineBarrier2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPipelineBarrier2KHR.html
23860 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
23861 VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier2KHR( const DependencyInfo * pDependencyInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
23862 {
23863 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
23864 d.vkCmdPipelineBarrier2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkDependencyInfo *>( pDependencyInfo ) );
23865 }
23866
23867 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
23868 // wrapper function for command vkCmdPipelineBarrier2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPipelineBarrier2KHR.html
23869 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
23870 VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier2KHR( const DependencyInfo & dependencyInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
23871 {
23872 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
23873 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
23874 VULKAN_HPP_ASSERT( d.vkCmdPipelineBarrier2KHR && "Function <vkCmdPipelineBarrier2KHR> requires <VK_KHR_synchronization2> or <VK_VERSION_1_3>" );
23875 # endif
23876
23877 d.vkCmdPipelineBarrier2KHR( m_commandBuffer, reinterpret_cast<const VkDependencyInfo *>( &dependencyInfo ) );
23878 }
23879 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
23880
23881 // wrapper function for command vkCmdWriteTimestamp2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteTimestamp2KHR.html
23882 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
23883 VULKAN_HPP_INLINE void
23884 CommandBuffer::writeTimestamp2KHR( PipelineStageFlags2 stage, QueryPool queryPool, uint32_t query, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
23885 {
23886 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
23887 d.vkCmdWriteTimestamp2KHR(
23888 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkPipelineStageFlags2>( stage ), static_cast<VkQueryPool>( queryPool ), query );
23889 }
23890
23891 // wrapper function for command vkQueueSubmit2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSubmit2KHR.html
23892 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
23893 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
23894 Queue::submit2KHR( uint32_t submitCount, const SubmitInfo2 * pSubmits, Fence fence, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
23895 {
23896 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
23897 return static_cast<Result>(
23898 d.vkQueueSubmit2KHR( static_cast<VkQueue>( m_queue ), submitCount, reinterpret_cast<const VkSubmitInfo2 *>( pSubmits ), static_cast<VkFence>( fence ) ) );
23899 }
23900
23901 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
23902 // wrapper function for command vkQueueSubmit2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSubmit2KHR.html
23903 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
23904 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
23905 Queue::submit2KHR( ArrayProxy<const SubmitInfo2> const & submits, Fence fence, Dispatch const & d ) const
23906 {
23907 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
23908 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
23909 VULKAN_HPP_ASSERT( d.vkQueueSubmit2KHR && "Function <vkQueueSubmit2KHR> requires <VK_KHR_synchronization2> or <VK_VERSION_1_3>" );
23910 # endif
23911
23912 Result result = static_cast<Result>(
23913 d.vkQueueSubmit2KHR( m_queue, submits.size(), reinterpret_cast<const VkSubmitInfo2 *>( submits.data() ), static_cast<VkFence>( fence ) ) );
23914 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::submit2KHR" );
23915
23916 return detail::createResultValueType( result );
23917 }
23918 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
23919
23920 //=== VK_EXT_descriptor_buffer ===
23921
23922 // wrapper function for command vkGetDescriptorSetLayoutSizeEXT, see
23923 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSizeEXT.html
23924 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
23925 VULKAN_HPP_INLINE void
23926 Device::getDescriptorSetLayoutSizeEXT( DescriptorSetLayout layout, DeviceSize * pLayoutSizeInBytes, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
23927 {
23928 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
23929 d.vkGetDescriptorSetLayoutSizeEXT(
23930 static_cast<VkDevice>( m_device ), static_cast<VkDescriptorSetLayout>( layout ), reinterpret_cast<VkDeviceSize *>( pLayoutSizeInBytes ) );
23931 }
23932
23933 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
23934 // wrapper function for command vkGetDescriptorSetLayoutSizeEXT, see
23935 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSizeEXT.html
23936 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
23937 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DeviceSize Device::getDescriptorSetLayoutSizeEXT( DescriptorSetLayout layout,
23938 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
23939 {
23940 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
23941 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
23942 VULKAN_HPP_ASSERT( d.vkGetDescriptorSetLayoutSizeEXT && "Function <vkGetDescriptorSetLayoutSizeEXT> requires <VK_EXT_descriptor_buffer>" );
23943 # endif
23944
23945 DeviceSize layoutSizeInBytes;
23946 d.vkGetDescriptorSetLayoutSizeEXT( m_device, static_cast<VkDescriptorSetLayout>( layout ), reinterpret_cast<VkDeviceSize *>( &layoutSizeInBytes ) );
23947
23948 return layoutSizeInBytes;
23949 }
23950 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
23951
23952 // wrapper function for command vkGetDescriptorSetLayoutBindingOffsetEXT, see
23953 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutBindingOffsetEXT.html
23954 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
23955 VULKAN_HPP_INLINE void Device::getDescriptorSetLayoutBindingOffsetEXT( DescriptorSetLayout layout,
23956 uint32_t binding,
23957 DeviceSize * pOffset,
23958 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
23959 {
23960 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
23961 d.vkGetDescriptorSetLayoutBindingOffsetEXT(
23962 static_cast<VkDevice>( m_device ), static_cast<VkDescriptorSetLayout>( layout ), binding, reinterpret_cast<VkDeviceSize *>( pOffset ) );
23963 }
23964
23965 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
23966 // wrapper function for command vkGetDescriptorSetLayoutBindingOffsetEXT, see
23967 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutBindingOffsetEXT.html
23968 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
23969 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DeviceSize Device::getDescriptorSetLayoutBindingOffsetEXT( DescriptorSetLayout layout,
23970 uint32_t binding,
23971 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
23972 {
23973 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
23974 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
23975 VULKAN_HPP_ASSERT( d.vkGetDescriptorSetLayoutBindingOffsetEXT &&
23976 "Function <vkGetDescriptorSetLayoutBindingOffsetEXT> requires <VK_EXT_descriptor_buffer>" );
23977 # endif
23978
23979 DeviceSize offset;
23980 d.vkGetDescriptorSetLayoutBindingOffsetEXT( m_device, static_cast<VkDescriptorSetLayout>( layout ), binding, reinterpret_cast<VkDeviceSize *>( &offset ) );
23981
23982 return offset;
23983 }
23984 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
23985
23986 // wrapper function for command vkGetDescriptorEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorEXT.html
23987 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
23988 VULKAN_HPP_INLINE void
23989 Device::getDescriptorEXT( const DescriptorGetInfoEXT * pDescriptorInfo, size_t dataSize, void * pDescriptor, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
23990 {
23991 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
23992 d.vkGetDescriptorEXT( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkDescriptorGetInfoEXT *>( pDescriptorInfo ), dataSize, pDescriptor );
23993 }
23994
23995 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
23996 // wrapper function for command vkGetDescriptorEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorEXT.html
23997 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
23998 VULKAN_HPP_INLINE void
23999 Device::getDescriptorEXT( const DescriptorGetInfoEXT & descriptorInfo, size_t dataSize, void * pDescriptor, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
24000 {
24001 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
24002 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
24003 VULKAN_HPP_ASSERT( d.vkGetDescriptorEXT && "Function <vkGetDescriptorEXT> requires <VK_EXT_descriptor_buffer>" );
24004 # endif
24005
24006 d.vkGetDescriptorEXT( m_device, reinterpret_cast<const VkDescriptorGetInfoEXT *>( &descriptorInfo ), dataSize, pDescriptor );
24007 }
24008
24009 // wrapper function for command vkGetDescriptorEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorEXT.html
24010 template <typename DescriptorType, typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
24011 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DescriptorType Device::getDescriptorEXT( const DescriptorGetInfoEXT & descriptorInfo,
24012 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
24013 {
24014 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
24015 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
24016 VULKAN_HPP_ASSERT( d.vkGetDescriptorEXT && "Function <vkGetDescriptorEXT> requires <VK_EXT_descriptor_buffer>" );
24017 # endif
24018
24019 DescriptorType descriptor;
24020 d.vkGetDescriptorEXT(
24021 m_device, reinterpret_cast<const VkDescriptorGetInfoEXT *>( &descriptorInfo ), sizeof( DescriptorType ), reinterpret_cast<void *>( &descriptor ) );
24022
24023 return descriptor;
24024 }
24025 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
24026
24027 // wrapper function for command vkCmdBindDescriptorBuffersEXT, see
24028 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorBuffersEXT.html
24029 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
24030 VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorBuffersEXT( uint32_t bufferCount,
24031 const DescriptorBufferBindingInfoEXT * pBindingInfos,
24032 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
24033 {
24034 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
24035 d.vkCmdBindDescriptorBuffersEXT(
24036 static_cast<VkCommandBuffer>( m_commandBuffer ), bufferCount, reinterpret_cast<const VkDescriptorBufferBindingInfoEXT *>( pBindingInfos ) );
24037 }
24038
24039 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
24040 // wrapper function for command vkCmdBindDescriptorBuffersEXT, see
24041 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorBuffersEXT.html
24042 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
24043 VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorBuffersEXT( ArrayProxy<const DescriptorBufferBindingInfoEXT> const & bindingInfos,
24044 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
24045 {
24046 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
24047 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
24048 VULKAN_HPP_ASSERT( d.vkCmdBindDescriptorBuffersEXT && "Function <vkCmdBindDescriptorBuffersEXT> requires <VK_EXT_descriptor_buffer>" );
24049 # endif
24050
24051 d.vkCmdBindDescriptorBuffersEXT( m_commandBuffer, bindingInfos.size(), reinterpret_cast<const VkDescriptorBufferBindingInfoEXT *>( bindingInfos.data() ) );
24052 }
24053 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
24054
24055 // wrapper function for command vkCmdSetDescriptorBufferOffsetsEXT, see
24056 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDescriptorBufferOffsetsEXT.html
24057 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
24058 VULKAN_HPP_INLINE void CommandBuffer::setDescriptorBufferOffsetsEXT( PipelineBindPoint pipelineBindPoint,
24059 PipelineLayout layout,
24060 uint32_t firstSet,
24061 uint32_t setCount,
24062 const uint32_t * pBufferIndices,
24063 const DeviceSize * pOffsets,
24064 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
24065 {
24066 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
24067 d.vkCmdSetDescriptorBufferOffsetsEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
24068 static_cast<VkPipelineBindPoint>( pipelineBindPoint ),
24069 static_cast<VkPipelineLayout>( layout ),
24070 firstSet,
24071 setCount,
24072 pBufferIndices,
24073 reinterpret_cast<const VkDeviceSize *>( pOffsets ) );
24074 }
24075
24076 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
24077 // wrapper function for command vkCmdSetDescriptorBufferOffsetsEXT, see
24078 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDescriptorBufferOffsetsEXT.html
24079 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
24080 VULKAN_HPP_INLINE void CommandBuffer::setDescriptorBufferOffsetsEXT( PipelineBindPoint pipelineBindPoint,
24081 PipelineLayout layout,
24082 uint32_t firstSet,
24083 ArrayProxy<const uint32_t> const & bufferIndices,
24084 ArrayProxy<const DeviceSize> const & offsets,
24085 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
24086 {
24087 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
24088 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
24089 VULKAN_HPP_ASSERT( d.vkCmdSetDescriptorBufferOffsetsEXT && "Function <vkCmdSetDescriptorBufferOffsetsEXT> requires <VK_EXT_descriptor_buffer>" );
24090 # endif
24091 # ifdef VULKAN_HPP_NO_EXCEPTIONS
24092 VULKAN_HPP_ASSERT( bufferIndices.size() == offsets.size() );
24093 # else
24094 if ( bufferIndices.size() != offsets.size() )
24095 {
24096 throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::setDescriptorBufferOffsetsEXT: bufferIndices.size() != offsets.size()" );
24097 }
24098 # endif /*VULKAN_HPP_NO_EXCEPTIONS*/
24099
24100 d.vkCmdSetDescriptorBufferOffsetsEXT( m_commandBuffer,
24101 static_cast<VkPipelineBindPoint>( pipelineBindPoint ),
24102 static_cast<VkPipelineLayout>( layout ),
24103 firstSet,
24104 bufferIndices.size(),
24105 bufferIndices.data(),
24106 reinterpret_cast<const VkDeviceSize *>( offsets.data() ) );
24107 }
24108 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
24109
24110 // wrapper function for command vkCmdBindDescriptorBufferEmbeddedSamplersEXT, see
24111 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorBufferEmbeddedSamplersEXT.html
24112 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
24113 VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorBufferEmbeddedSamplersEXT( PipelineBindPoint pipelineBindPoint,
24114 PipelineLayout layout,
24115 uint32_t set,
24116 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
24117 {
24118 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
24119 d.vkCmdBindDescriptorBufferEmbeddedSamplersEXT(
24120 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkPipelineBindPoint>( pipelineBindPoint ), static_cast<VkPipelineLayout>( layout ), set );
24121 }
24122
24123 // wrapper function for command vkGetBufferOpaqueCaptureDescriptorDataEXT, see
24124 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferOpaqueCaptureDescriptorDataEXT.html
24125 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
24126 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getBufferOpaqueCaptureDescriptorDataEXT( const BufferCaptureDescriptorDataInfoEXT * pInfo,
24127 void * pData,
24128 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
24129 {
24130 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
24131 return static_cast<Result>( d.vkGetBufferOpaqueCaptureDescriptorDataEXT(
24132 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkBufferCaptureDescriptorDataInfoEXT *>( pInfo ), pData ) );
24133 }
24134
24135 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
24136 // wrapper function for command vkGetBufferOpaqueCaptureDescriptorDataEXT, see
24137 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferOpaqueCaptureDescriptorDataEXT.html
24138 template <typename DataType, typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
24139 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<DataType>::type
24140 Device::getBufferOpaqueCaptureDescriptorDataEXT( const BufferCaptureDescriptorDataInfoEXT & info, Dispatch const & d ) const
24141 {
24142 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
24143 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
24144 VULKAN_HPP_ASSERT( d.vkGetBufferOpaqueCaptureDescriptorDataEXT &&
24145 "Function <vkGetBufferOpaqueCaptureDescriptorDataEXT> requires <VK_EXT_descriptor_buffer>" );
24146 # endif
24147
24148 DataType data;
24149 Result result = static_cast<Result>(
24150 d.vkGetBufferOpaqueCaptureDescriptorDataEXT( m_device, reinterpret_cast<const VkBufferCaptureDescriptorDataInfoEXT *>( &info ), &data ) );
24151 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getBufferOpaqueCaptureDescriptorDataEXT" );
24152
24153 return detail::createResultValueType( result, std::move( data ) );
24154 }
24155 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
24156
24157 // wrapper function for command vkGetImageOpaqueCaptureDescriptorDataEXT, see
24158 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageOpaqueCaptureDescriptorDataEXT.html
24159 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
24160 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getImageOpaqueCaptureDescriptorDataEXT( const ImageCaptureDescriptorDataInfoEXT * pInfo,
24161 void * pData,
24162 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
24163 {
24164 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
24165 return static_cast<Result>( d.vkGetImageOpaqueCaptureDescriptorDataEXT(
24166 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkImageCaptureDescriptorDataInfoEXT *>( pInfo ), pData ) );
24167 }
24168
24169 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
24170 // wrapper function for command vkGetImageOpaqueCaptureDescriptorDataEXT, see
24171 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageOpaqueCaptureDescriptorDataEXT.html
24172 template <typename DataType, typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
24173 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<DataType>::type
24174 Device::getImageOpaqueCaptureDescriptorDataEXT( const ImageCaptureDescriptorDataInfoEXT & info, Dispatch const & d ) const
24175 {
24176 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
24177 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
24178 VULKAN_HPP_ASSERT( d.vkGetImageOpaqueCaptureDescriptorDataEXT &&
24179 "Function <vkGetImageOpaqueCaptureDescriptorDataEXT> requires <VK_EXT_descriptor_buffer>" );
24180 # endif
24181
24182 DataType data;
24183 Result result = static_cast<Result>(
24184 d.vkGetImageOpaqueCaptureDescriptorDataEXT( m_device, reinterpret_cast<const VkImageCaptureDescriptorDataInfoEXT *>( &info ), &data ) );
24185 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getImageOpaqueCaptureDescriptorDataEXT" );
24186
24187 return detail::createResultValueType( result, std::move( data ) );
24188 }
24189 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
24190
24191 // wrapper function for command vkGetImageViewOpaqueCaptureDescriptorDataEXT, see
24192 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewOpaqueCaptureDescriptorDataEXT.html
24193 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
24194 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getImageViewOpaqueCaptureDescriptorDataEXT( const ImageViewCaptureDescriptorDataInfoEXT * pInfo,
24195 void * pData,
24196 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
24197 {
24198 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
24199 return static_cast<Result>( d.vkGetImageViewOpaqueCaptureDescriptorDataEXT(
24200 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkImageViewCaptureDescriptorDataInfoEXT *>( pInfo ), pData ) );
24201 }
24202
24203 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
24204 // wrapper function for command vkGetImageViewOpaqueCaptureDescriptorDataEXT, see
24205 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewOpaqueCaptureDescriptorDataEXT.html
24206 template <typename DataType, typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
24207 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<DataType>::type
24208 Device::getImageViewOpaqueCaptureDescriptorDataEXT( const ImageViewCaptureDescriptorDataInfoEXT & info, Dispatch const & d ) const
24209 {
24210 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
24211 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
24212 VULKAN_HPP_ASSERT( d.vkGetImageViewOpaqueCaptureDescriptorDataEXT &&
24213 "Function <vkGetImageViewOpaqueCaptureDescriptorDataEXT> requires <VK_EXT_descriptor_buffer>" );
24214 # endif
24215
24216 DataType data;
24217 Result result = static_cast<Result>(
24218 d.vkGetImageViewOpaqueCaptureDescriptorDataEXT( m_device, reinterpret_cast<const VkImageViewCaptureDescriptorDataInfoEXT *>( &info ), &data ) );
24219 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getImageViewOpaqueCaptureDescriptorDataEXT" );
24220
24221 return detail::createResultValueType( result, std::move( data ) );
24222 }
24223 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
24224
24225 // wrapper function for command vkGetSamplerOpaqueCaptureDescriptorDataEXT, see
24226 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSamplerOpaqueCaptureDescriptorDataEXT.html
24227 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
24228 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSamplerOpaqueCaptureDescriptorDataEXT( const SamplerCaptureDescriptorDataInfoEXT * pInfo,
24229 void * pData,
24230 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
24231 {
24232 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
24233 return static_cast<Result>( d.vkGetSamplerOpaqueCaptureDescriptorDataEXT(
24234 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkSamplerCaptureDescriptorDataInfoEXT *>( pInfo ), pData ) );
24235 }
24236
24237 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
24238 // wrapper function for command vkGetSamplerOpaqueCaptureDescriptorDataEXT, see
24239 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSamplerOpaqueCaptureDescriptorDataEXT.html
24240 template <typename DataType, typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
24241 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<DataType>::type
24242 Device::getSamplerOpaqueCaptureDescriptorDataEXT( const SamplerCaptureDescriptorDataInfoEXT & info, Dispatch const & d ) const
24243 {
24244 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
24245 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
24246 VULKAN_HPP_ASSERT( d.vkGetSamplerOpaqueCaptureDescriptorDataEXT &&
24247 "Function <vkGetSamplerOpaqueCaptureDescriptorDataEXT> requires <VK_EXT_descriptor_buffer>" );
24248 # endif
24249
24250 DataType data;
24251 Result result = static_cast<Result>(
24252 d.vkGetSamplerOpaqueCaptureDescriptorDataEXT( m_device, reinterpret_cast<const VkSamplerCaptureDescriptorDataInfoEXT *>( &info ), &data ) );
24253 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSamplerOpaqueCaptureDescriptorDataEXT" );
24254
24255 return detail::createResultValueType( result, std::move( data ) );
24256 }
24257 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
24258
24259 // wrapper function for command vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT, see
24260 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT.html
24261 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
24262 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getAccelerationStructureOpaqueCaptureDescriptorDataEXT(
24263 const AccelerationStructureCaptureDescriptorDataInfoEXT * pInfo, void * pData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
24264 {
24265 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
24266 return static_cast<Result>( d.vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(
24267 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkAccelerationStructureCaptureDescriptorDataInfoEXT *>( pInfo ), pData ) );
24268 }
24269
24270 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
24271 // wrapper function for command vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT, see
24272 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT.html
24273 template <typename DataType, typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
24274 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<DataType>::type
24275 Device::getAccelerationStructureOpaqueCaptureDescriptorDataEXT( const AccelerationStructureCaptureDescriptorDataInfoEXT & info, Dispatch const & d ) const
24276 {
24277 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
24278 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
24279 VULKAN_HPP_ASSERT( d.vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT &&
24280 "Function <vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT> requires <VK_EXT_descriptor_buffer>" );
24281 # endif
24282
24283 DataType data;
24284 Result result = static_cast<Result>( d.vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(
24285 m_device, reinterpret_cast<const VkAccelerationStructureCaptureDescriptorDataInfoEXT *>( &info ), &data ) );
24286 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getAccelerationStructureOpaqueCaptureDescriptorDataEXT" );
24287
24288 return detail::createResultValueType( result, std::move( data ) );
24289 }
24290 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
24291
24292 //=== VK_NV_fragment_shading_rate_enums ===
24293
24294 // wrapper function for command vkCmdSetFragmentShadingRateEnumNV, see
24295 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFragmentShadingRateEnumNV.html
24296 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
24297 VULKAN_HPP_INLINE void CommandBuffer::setFragmentShadingRateEnumNV( FragmentShadingRateNV shadingRate,
24298 const FragmentShadingRateCombinerOpKHR combinerOps[2],
24299 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
24300 {
24301 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
24302 d.vkCmdSetFragmentShadingRateEnumNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
24303 static_cast<VkFragmentShadingRateNV>( shadingRate ),
24304 reinterpret_cast<const VkFragmentShadingRateCombinerOpKHR *>( combinerOps ) );
24305 }
24306
24307 //=== VK_EXT_mesh_shader ===
24308
24309 // wrapper function for command vkCmdDrawMeshTasksEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksEXT.html
24310 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
24311 VULKAN_HPP_INLINE void
24312 CommandBuffer::drawMeshTasksEXT( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
24313 {
24314 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
24315 d.vkCmdDrawMeshTasksEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), groupCountX, groupCountY, groupCountZ );
24316 }
24317
24318 // wrapper function for command vkCmdDrawMeshTasksIndirectEXT, see
24319 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksIndirectEXT.html
24320 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
24321 VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectEXT(
24322 Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
24323 {
24324 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
24325 d.vkCmdDrawMeshTasksIndirectEXT(
24326 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), drawCount, stride );
24327 }
24328
24329 // wrapper function for command vkCmdDrawMeshTasksIndirectCountEXT, see
24330 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksIndirectCountEXT.html
24331 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
24332 VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectCountEXT( Buffer buffer,
24333 DeviceSize offset,
24334 Buffer countBuffer,
24335 DeviceSize countBufferOffset,
24336 uint32_t maxDrawCount,
24337 uint32_t stride,
24338 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
24339 {
24340 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
24341 d.vkCmdDrawMeshTasksIndirectCountEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
24342 static_cast<VkBuffer>( buffer ),
24343 static_cast<VkDeviceSize>( offset ),
24344 static_cast<VkBuffer>( countBuffer ),
24345 static_cast<VkDeviceSize>( countBufferOffset ),
24346 maxDrawCount,
24347 stride );
24348 }
24349
24350 //=== VK_KHR_copy_commands2 ===
24351
24352 // wrapper function for command vkCmdCopyBuffer2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBuffer2KHR.html
24353 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
24354 VULKAN_HPP_INLINE void CommandBuffer::copyBuffer2KHR( const CopyBufferInfo2 * pCopyBufferInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
24355 {
24356 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
24357 d.vkCmdCopyBuffer2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkCopyBufferInfo2 *>( pCopyBufferInfo ) );
24358 }
24359
24360 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
24361 // wrapper function for command vkCmdCopyBuffer2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBuffer2KHR.html
24362 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
24363 VULKAN_HPP_INLINE void CommandBuffer::copyBuffer2KHR( const CopyBufferInfo2 & copyBufferInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
24364 {
24365 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
24366 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
24367 VULKAN_HPP_ASSERT( d.vkCmdCopyBuffer2KHR && "Function <vkCmdCopyBuffer2KHR> requires <VK_KHR_copy_commands2> or <VK_VERSION_1_3>" );
24368 # endif
24369
24370 d.vkCmdCopyBuffer2KHR( m_commandBuffer, reinterpret_cast<const VkCopyBufferInfo2 *>( &copyBufferInfo ) );
24371 }
24372 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
24373
24374 // wrapper function for command vkCmdCopyImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImage2KHR.html
24375 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
24376 VULKAN_HPP_INLINE void CommandBuffer::copyImage2KHR( const CopyImageInfo2 * pCopyImageInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
24377 {
24378 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
24379 d.vkCmdCopyImage2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkCopyImageInfo2 *>( pCopyImageInfo ) );
24380 }
24381
24382 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
24383 // wrapper function for command vkCmdCopyImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImage2KHR.html
24384 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
24385 VULKAN_HPP_INLINE void CommandBuffer::copyImage2KHR( const CopyImageInfo2 & copyImageInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
24386 {
24387 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
24388 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
24389 VULKAN_HPP_ASSERT( d.vkCmdCopyImage2KHR && "Function <vkCmdCopyImage2KHR> requires <VK_KHR_copy_commands2> or <VK_VERSION_1_3>" );
24390 # endif
24391
24392 d.vkCmdCopyImage2KHR( m_commandBuffer, reinterpret_cast<const VkCopyImageInfo2 *>( &copyImageInfo ) );
24393 }
24394 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
24395
24396 // wrapper function for command vkCmdCopyBufferToImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBufferToImage2KHR.html
24397 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
24398 VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage2KHR( const CopyBufferToImageInfo2 * pCopyBufferToImageInfo,
24399 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
24400 {
24401 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
24402 d.vkCmdCopyBufferToImage2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
24403 reinterpret_cast<const VkCopyBufferToImageInfo2 *>( pCopyBufferToImageInfo ) );
24404 }
24405
24406 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
24407 // wrapper function for command vkCmdCopyBufferToImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBufferToImage2KHR.html
24408 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
24409 VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage2KHR( const CopyBufferToImageInfo2 & copyBufferToImageInfo,
24410 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
24411 {
24412 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
24413 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
24414 VULKAN_HPP_ASSERT( d.vkCmdCopyBufferToImage2KHR && "Function <vkCmdCopyBufferToImage2KHR> requires <VK_KHR_copy_commands2> or <VK_VERSION_1_3>" );
24415 # endif
24416
24417 d.vkCmdCopyBufferToImage2KHR( m_commandBuffer, reinterpret_cast<const VkCopyBufferToImageInfo2 *>( &copyBufferToImageInfo ) );
24418 }
24419 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
24420
24421 // wrapper function for command vkCmdCopyImageToBuffer2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToBuffer2KHR.html
24422 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
24423 VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer2KHR( const CopyImageToBufferInfo2 * pCopyImageToBufferInfo,
24424 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
24425 {
24426 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
24427 d.vkCmdCopyImageToBuffer2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
24428 reinterpret_cast<const VkCopyImageToBufferInfo2 *>( pCopyImageToBufferInfo ) );
24429 }
24430
24431 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
24432 // wrapper function for command vkCmdCopyImageToBuffer2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToBuffer2KHR.html
24433 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
24434 VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer2KHR( const CopyImageToBufferInfo2 & copyImageToBufferInfo,
24435 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
24436 {
24437 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
24438 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
24439 VULKAN_HPP_ASSERT( d.vkCmdCopyImageToBuffer2KHR && "Function <vkCmdCopyImageToBuffer2KHR> requires <VK_KHR_copy_commands2> or <VK_VERSION_1_3>" );
24440 # endif
24441
24442 d.vkCmdCopyImageToBuffer2KHR( m_commandBuffer, reinterpret_cast<const VkCopyImageToBufferInfo2 *>( &copyImageToBufferInfo ) );
24443 }
24444 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
24445
24446 // wrapper function for command vkCmdBlitImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBlitImage2KHR.html
24447 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
24448 VULKAN_HPP_INLINE void CommandBuffer::blitImage2KHR( const BlitImageInfo2 * pBlitImageInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
24449 {
24450 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
24451 d.vkCmdBlitImage2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkBlitImageInfo2 *>( pBlitImageInfo ) );
24452 }
24453
24454 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
24455 // wrapper function for command vkCmdBlitImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBlitImage2KHR.html
24456 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
24457 VULKAN_HPP_INLINE void CommandBuffer::blitImage2KHR( const BlitImageInfo2 & blitImageInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
24458 {
24459 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
24460 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
24461 VULKAN_HPP_ASSERT( d.vkCmdBlitImage2KHR && "Function <vkCmdBlitImage2KHR> requires <VK_KHR_copy_commands2> or <VK_VERSION_1_3>" );
24462 # endif
24463
24464 d.vkCmdBlitImage2KHR( m_commandBuffer, reinterpret_cast<const VkBlitImageInfo2 *>( &blitImageInfo ) );
24465 }
24466 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
24467
24468 // wrapper function for command vkCmdResolveImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResolveImage2KHR.html
24469 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
24470 VULKAN_HPP_INLINE void CommandBuffer::resolveImage2KHR( const ResolveImageInfo2 * pResolveImageInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
24471 {
24472 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
24473 d.vkCmdResolveImage2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkResolveImageInfo2 *>( pResolveImageInfo ) );
24474 }
24475
24476 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
24477 // wrapper function for command vkCmdResolveImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResolveImage2KHR.html
24478 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
24479 VULKAN_HPP_INLINE void CommandBuffer::resolveImage2KHR( const ResolveImageInfo2 & resolveImageInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
24480 {
24481 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
24482 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
24483 VULKAN_HPP_ASSERT( d.vkCmdResolveImage2KHR && "Function <vkCmdResolveImage2KHR> requires <VK_KHR_copy_commands2> or <VK_VERSION_1_3>" );
24484 # endif
24485
24486 d.vkCmdResolveImage2KHR( m_commandBuffer, reinterpret_cast<const VkResolveImageInfo2 *>( &resolveImageInfo ) );
24487 }
24488 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
24489
24490 //=== VK_EXT_device_fault ===
24491
24492 // wrapper function for command vkGetDeviceFaultInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceFaultInfoEXT.html
24493 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
24494 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getFaultInfoEXT( DeviceFaultCountsEXT * pFaultCounts,
24495 DeviceFaultInfoEXT * pFaultInfo,
24496 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
24497 {
24498 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
24499 return static_cast<Result>( d.vkGetDeviceFaultInfoEXT(
24500 static_cast<VkDevice>( m_device ), reinterpret_cast<VkDeviceFaultCountsEXT *>( pFaultCounts ), reinterpret_cast<VkDeviceFaultInfoEXT *>( pFaultInfo ) ) );
24501 }
24502
24503 #if defined( VK_USE_PLATFORM_WIN32_KHR )
24504 //=== VK_NV_acquire_winrt_display ===
24505
24506 # ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
24507 // wrapper function for command vkAcquireWinrtDisplayNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireWinrtDisplayNV.html
24508 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
24509 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::acquireWinrtDisplayNV( DisplayKHR display, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
24510 {
24511 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
24512 return static_cast<Result>( d.vkAcquireWinrtDisplayNV( static_cast<VkPhysicalDevice>( m_physicalDevice ), static_cast<VkDisplayKHR>( display ) ) );
24513 }
24514 # else
24515 // wrapper function for command vkAcquireWinrtDisplayNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireWinrtDisplayNV.html
24516 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
24517 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
24518 PhysicalDevice::acquireWinrtDisplayNV( DisplayKHR display, Dispatch const & d ) const
24519 {
24520 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
24521 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
24522 VULKAN_HPP_ASSERT( d.vkAcquireWinrtDisplayNV && "Function <vkAcquireWinrtDisplayNV> requires <VK_NV_acquire_winrt_display>" );
24523 # endif
24524
24525 Result result = static_cast<Result>( d.vkAcquireWinrtDisplayNV( m_physicalDevice, static_cast<VkDisplayKHR>( display ) ) );
24526 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::acquireWinrtDisplayNV" );
24527
24528 return detail::createResultValueType( result );
24529 }
24530 # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
24531
24532 // wrapper function for command vkGetWinrtDisplayNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetWinrtDisplayNV.html
24533 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
24534 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getWinrtDisplayNV( uint32_t deviceRelativeId,
24535 DisplayKHR * pDisplay,
24536 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
24537 {
24538 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
24539 return static_cast<Result>(
24540 d.vkGetWinrtDisplayNV( static_cast<VkPhysicalDevice>( m_physicalDevice ), deviceRelativeId, reinterpret_cast<VkDisplayKHR *>( pDisplay ) ) );
24541 }
24542
24543 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
24544 // wrapper function for command vkGetWinrtDisplayNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetWinrtDisplayNV.html
24545 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
24546 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<DisplayKHR>::type PhysicalDevice::getWinrtDisplayNV( uint32_t deviceRelativeId,
24547 Dispatch const & d ) const
24548 {
24549 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
24550 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
24551 VULKAN_HPP_ASSERT( d.vkGetWinrtDisplayNV && "Function <vkGetWinrtDisplayNV> requires <VK_NV_acquire_winrt_display>" );
24552 # endif
24553
24554 DisplayKHR display;
24555 Result result = static_cast<Result>( d.vkGetWinrtDisplayNV( m_physicalDevice, deviceRelativeId, reinterpret_cast<VkDisplayKHR *>( &display ) ) );
24556 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getWinrtDisplayNV" );
24557
24558 return detail::createResultValueType( result, std::move( display ) );
24559 }
24560
24561 # ifndef VULKAN_HPP_NO_SMART_HANDLE
24562 // wrapper function for command vkGetWinrtDisplayNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetWinrtDisplayNV.html
24563 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
24564 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<DisplayKHR, Dispatch>>::type
24565 PhysicalDevice::getWinrtDisplayNVUnique( uint32_t deviceRelativeId, Dispatch const & d ) const
24566 {
24567 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
24568 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
24569 VULKAN_HPP_ASSERT( d.vkGetWinrtDisplayNV && "Function <vkGetWinrtDisplayNV> requires <VK_NV_acquire_winrt_display>" );
24570 # endif
24571
24572 DisplayKHR display;
24573 Result result = static_cast<Result>( d.vkGetWinrtDisplayNV( m_physicalDevice, deviceRelativeId, reinterpret_cast<VkDisplayKHR *>( &display ) ) );
24574 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getWinrtDisplayNVUnique" );
24575
24576 return detail::createResultValueType( result, UniqueHandle<DisplayKHR, Dispatch>( display, detail::ObjectRelease<PhysicalDevice, Dispatch>( *this, d ) ) );
24577 }
24578 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
24579 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
24580 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
24581
24582 #if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
24583 //=== VK_EXT_directfb_surface ===
24584
24585 // wrapper function for command vkCreateDirectFBSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDirectFBSurfaceEXT.html
24586 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
24587 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createDirectFBSurfaceEXT( const DirectFBSurfaceCreateInfoEXT * pCreateInfo,
24588 const AllocationCallbacks * pAllocator,
24589 SurfaceKHR * pSurface,
24590 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
24591 {
24592 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
24593 return static_cast<Result>( d.vkCreateDirectFBSurfaceEXT( static_cast<VkInstance>( m_instance ),
24594 reinterpret_cast<const VkDirectFBSurfaceCreateInfoEXT *>( pCreateInfo ),
24595 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
24596 reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) );
24597 }
24598
24599 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
24600 // wrapper function for command vkCreateDirectFBSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDirectFBSurfaceEXT.html
24601 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
24602 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<SurfaceKHR>::type Instance::createDirectFBSurfaceEXT(
24603 const DirectFBSurfaceCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
24604 {
24605 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
24606 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
24607 VULKAN_HPP_ASSERT( d.vkCreateDirectFBSurfaceEXT && "Function <vkCreateDirectFBSurfaceEXT> requires <VK_EXT_directfb_surface>" );
24608 # endif
24609
24610 SurfaceKHR surface;
24611 Result result = static_cast<Result>( d.vkCreateDirectFBSurfaceEXT( m_instance,
24612 reinterpret_cast<const VkDirectFBSurfaceCreateInfoEXT *>( &createInfo ),
24613 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
24614 reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
24615 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDirectFBSurfaceEXT" );
24616
24617 return detail::createResultValueType( result, std::move( surface ) );
24618 }
24619
24620 # ifndef VULKAN_HPP_NO_SMART_HANDLE
24621 // wrapper function for command vkCreateDirectFBSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDirectFBSurfaceEXT.html
24622 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
24623 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type Instance::createDirectFBSurfaceEXTUnique(
24624 const DirectFBSurfaceCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
24625 {
24626 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
24627 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
24628 VULKAN_HPP_ASSERT( d.vkCreateDirectFBSurfaceEXT && "Function <vkCreateDirectFBSurfaceEXT> requires <VK_EXT_directfb_surface>" );
24629 # endif
24630
24631 SurfaceKHR surface;
24632 Result result = static_cast<Result>( d.vkCreateDirectFBSurfaceEXT( m_instance,
24633 reinterpret_cast<const VkDirectFBSurfaceCreateInfoEXT *>( &createInfo ),
24634 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
24635 reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
24636 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDirectFBSurfaceEXTUnique" );
24637
24638 return detail::createResultValueType( result,
24639 UniqueHandle<SurfaceKHR, Dispatch>( surface, detail::ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) );
24640 }
24641 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
24642 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
24643
24644 // wrapper function for command vkGetPhysicalDeviceDirectFBPresentationSupportEXT, see
24645 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDirectFBPresentationSupportEXT.html
24646 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
24647 VULKAN_HPP_INLINE Bool32 PhysicalDevice::getDirectFBPresentationSupportEXT( uint32_t queueFamilyIndex,
24648 IDirectFB * dfb,
24649 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
24650 {
24651 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
24652 return static_cast<Bool32>(
24653 d.vkGetPhysicalDeviceDirectFBPresentationSupportEXT( static_cast<VkPhysicalDevice>( m_physicalDevice ), queueFamilyIndex, dfb ) );
24654 }
24655
24656 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
24657 // wrapper function for command vkGetPhysicalDeviceDirectFBPresentationSupportEXT, see
24658 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDirectFBPresentationSupportEXT.html
24659 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
24660 VULKAN_HPP_INLINE Bool32 PhysicalDevice::getDirectFBPresentationSupportEXT( uint32_t queueFamilyIndex,
24661 IDirectFB & dfb,
24662 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
24663 {
24664 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
24665 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
24666 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceDirectFBPresentationSupportEXT &&
24667 "Function <vkGetPhysicalDeviceDirectFBPresentationSupportEXT> requires <VK_EXT_directfb_surface>" );
24668 # endif
24669
24670 VkBool32 result = d.vkGetPhysicalDeviceDirectFBPresentationSupportEXT( m_physicalDevice, queueFamilyIndex, &dfb );
24671
24672 return static_cast<Bool32>( result );
24673 }
24674 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
24675 #endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
24676
24677 //=== VK_EXT_vertex_input_dynamic_state ===
24678
24679 // wrapper function for command vkCmdSetVertexInputEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetVertexInputEXT.html
24680 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
24681 VULKAN_HPP_INLINE void CommandBuffer::setVertexInputEXT( uint32_t vertexBindingDescriptionCount,
24682 const VertexInputBindingDescription2EXT * pVertexBindingDescriptions,
24683 uint32_t vertexAttributeDescriptionCount,
24684 const VertexInputAttributeDescription2EXT * pVertexAttributeDescriptions,
24685 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
24686 {
24687 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
24688 d.vkCmdSetVertexInputEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
24689 vertexBindingDescriptionCount,
24690 reinterpret_cast<const VkVertexInputBindingDescription2EXT *>( pVertexBindingDescriptions ),
24691 vertexAttributeDescriptionCount,
24692 reinterpret_cast<const VkVertexInputAttributeDescription2EXT *>( pVertexAttributeDescriptions ) );
24693 }
24694
24695 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
24696 // wrapper function for command vkCmdSetVertexInputEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetVertexInputEXT.html
24697 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
24698 VULKAN_HPP_INLINE void CommandBuffer::setVertexInputEXT( ArrayProxy<const VertexInputBindingDescription2EXT> const & vertexBindingDescriptions,
24699 ArrayProxy<const VertexInputAttributeDescription2EXT> const & vertexAttributeDescriptions,
24700 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
24701 {
24702 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
24703 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
24704 VULKAN_HPP_ASSERT( d.vkCmdSetVertexInputEXT && "Function <vkCmdSetVertexInputEXT> requires <VK_EXT_shader_object> or <VK_EXT_vertex_input_dynamic_state>" );
24705 # endif
24706
24707 d.vkCmdSetVertexInputEXT( m_commandBuffer,
24708 vertexBindingDescriptions.size(),
24709 reinterpret_cast<const VkVertexInputBindingDescription2EXT *>( vertexBindingDescriptions.data() ),
24710 vertexAttributeDescriptions.size(),
24711 reinterpret_cast<const VkVertexInputAttributeDescription2EXT *>( vertexAttributeDescriptions.data() ) );
24712 }
24713 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
24714
24715 #if defined( VK_USE_PLATFORM_FUCHSIA )
24716 //=== VK_FUCHSIA_external_memory ===
24717
24718 // wrapper function for command vkGetMemoryZirconHandleFUCHSIA, see
24719 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryZirconHandleFUCHSIA.html
24720 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
24721 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getMemoryZirconHandleFUCHSIA( const MemoryGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo,
24722 zx_handle_t * pZirconHandle,
24723 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
24724 {
24725 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
24726 return static_cast<Result>( d.vkGetMemoryZirconHandleFUCHSIA(
24727 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkMemoryGetZirconHandleInfoFUCHSIA *>( pGetZirconHandleInfo ), pZirconHandle ) );
24728 }
24729
24730 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
24731 // wrapper function for command vkGetMemoryZirconHandleFUCHSIA, see
24732 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryZirconHandleFUCHSIA.html
24733 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
24734 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<zx_handle_t>::type
24735 Device::getMemoryZirconHandleFUCHSIA( const MemoryGetZirconHandleInfoFUCHSIA & getZirconHandleInfo, Dispatch const & d ) const
24736 {
24737 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
24738 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
24739 VULKAN_HPP_ASSERT( d.vkGetMemoryZirconHandleFUCHSIA && "Function <vkGetMemoryZirconHandleFUCHSIA> requires <VK_FUCHSIA_external_memory>" );
24740 # endif
24741
24742 zx_handle_t zirconHandle;
24743 Result result = static_cast<Result>(
24744 d.vkGetMemoryZirconHandleFUCHSIA( m_device, reinterpret_cast<const VkMemoryGetZirconHandleInfoFUCHSIA *>( &getZirconHandleInfo ), &zirconHandle ) );
24745 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryZirconHandleFUCHSIA" );
24746
24747 return detail::createResultValueType( result, std::move( zirconHandle ) );
24748 }
24749 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
24750
24751 // wrapper function for command vkGetMemoryZirconHandlePropertiesFUCHSIA, see
24752 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryZirconHandlePropertiesFUCHSIA.html
24753 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
24754 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
24755 Device::getMemoryZirconHandlePropertiesFUCHSIA( ExternalMemoryHandleTypeFlagBits handleType,
24756 zx_handle_t zirconHandle,
24757 MemoryZirconHandlePropertiesFUCHSIA * pMemoryZirconHandleProperties,
24758 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
24759 {
24760 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
24761 return static_cast<Result>(
24762 d.vkGetMemoryZirconHandlePropertiesFUCHSIA( static_cast<VkDevice>( m_device ),
24763 static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ),
24764 zirconHandle,
24765 reinterpret_cast<VkMemoryZirconHandlePropertiesFUCHSIA *>( pMemoryZirconHandleProperties ) ) );
24766 }
24767
24768 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
24769 // wrapper function for command vkGetMemoryZirconHandlePropertiesFUCHSIA, see
24770 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryZirconHandlePropertiesFUCHSIA.html
24771 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
24772 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<MemoryZirconHandlePropertiesFUCHSIA>::type
24773 Device::getMemoryZirconHandlePropertiesFUCHSIA( ExternalMemoryHandleTypeFlagBits handleType, zx_handle_t zirconHandle, Dispatch const & d ) const
24774 {
24775 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
24776 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
24777 VULKAN_HPP_ASSERT( d.vkGetMemoryZirconHandlePropertiesFUCHSIA &&
24778 "Function <vkGetMemoryZirconHandlePropertiesFUCHSIA> requires <VK_FUCHSIA_external_memory>" );
24779 # endif
24780
24781 MemoryZirconHandlePropertiesFUCHSIA memoryZirconHandleProperties;
24782 Result result = static_cast<Result>(
24783 d.vkGetMemoryZirconHandlePropertiesFUCHSIA( m_device,
24784 static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ),
24785 zirconHandle,
24786 reinterpret_cast<VkMemoryZirconHandlePropertiesFUCHSIA *>( &memoryZirconHandleProperties ) ) );
24787 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryZirconHandlePropertiesFUCHSIA" );
24788
24789 return detail::createResultValueType( result, std::move( memoryZirconHandleProperties ) );
24790 }
24791 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
24792 #endif /*VK_USE_PLATFORM_FUCHSIA*/
24793
24794 #if defined( VK_USE_PLATFORM_FUCHSIA )
24795 //=== VK_FUCHSIA_external_semaphore ===
24796
24797 // wrapper function for command vkImportSemaphoreZirconHandleFUCHSIA, see
24798 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportSemaphoreZirconHandleFUCHSIA.html
24799 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
24800 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::importSemaphoreZirconHandleFUCHSIA(
24801 const ImportSemaphoreZirconHandleInfoFUCHSIA * pImportSemaphoreZirconHandleInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
24802 {
24803 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
24804 return static_cast<Result>( d.vkImportSemaphoreZirconHandleFUCHSIA(
24805 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkImportSemaphoreZirconHandleInfoFUCHSIA *>( pImportSemaphoreZirconHandleInfo ) ) );
24806 }
24807
24808 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
24809 // wrapper function for command vkImportSemaphoreZirconHandleFUCHSIA, see
24810 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportSemaphoreZirconHandleFUCHSIA.html
24811 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
24812 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
24813 Device::importSemaphoreZirconHandleFUCHSIA( const ImportSemaphoreZirconHandleInfoFUCHSIA & importSemaphoreZirconHandleInfo, Dispatch const & d ) const
24814 {
24815 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
24816 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
24817 VULKAN_HPP_ASSERT( d.vkImportSemaphoreZirconHandleFUCHSIA && "Function <vkImportSemaphoreZirconHandleFUCHSIA> requires <VK_FUCHSIA_external_semaphore>" );
24818 # endif
24819
24820 Result result = static_cast<Result>( d.vkImportSemaphoreZirconHandleFUCHSIA(
24821 m_device, reinterpret_cast<const VkImportSemaphoreZirconHandleInfoFUCHSIA *>( &importSemaphoreZirconHandleInfo ) ) );
24822 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::importSemaphoreZirconHandleFUCHSIA" );
24823
24824 return detail::createResultValueType( result );
24825 }
24826 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
24827
24828 // wrapper function for command vkGetSemaphoreZirconHandleFUCHSIA, see
24829 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreZirconHandleFUCHSIA.html
24830 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
24831 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSemaphoreZirconHandleFUCHSIA( const SemaphoreGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo,
24832 zx_handle_t * pZirconHandle,
24833 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
24834 {
24835 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
24836 return static_cast<Result>( d.vkGetSemaphoreZirconHandleFUCHSIA(
24837 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkSemaphoreGetZirconHandleInfoFUCHSIA *>( pGetZirconHandleInfo ), pZirconHandle ) );
24838 }
24839
24840 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
24841 // wrapper function for command vkGetSemaphoreZirconHandleFUCHSIA, see
24842 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreZirconHandleFUCHSIA.html
24843 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
24844 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<zx_handle_t>::type
24845 Device::getSemaphoreZirconHandleFUCHSIA( const SemaphoreGetZirconHandleInfoFUCHSIA & getZirconHandleInfo, Dispatch const & d ) const
24846 {
24847 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
24848 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
24849 VULKAN_HPP_ASSERT( d.vkGetSemaphoreZirconHandleFUCHSIA && "Function <vkGetSemaphoreZirconHandleFUCHSIA> requires <VK_FUCHSIA_external_semaphore>" );
24850 # endif
24851
24852 zx_handle_t zirconHandle;
24853 Result result = static_cast<Result>(
24854 d.vkGetSemaphoreZirconHandleFUCHSIA( m_device, reinterpret_cast<const VkSemaphoreGetZirconHandleInfoFUCHSIA *>( &getZirconHandleInfo ), &zirconHandle ) );
24855 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreZirconHandleFUCHSIA" );
24856
24857 return detail::createResultValueType( result, std::move( zirconHandle ) );
24858 }
24859 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
24860 #endif /*VK_USE_PLATFORM_FUCHSIA*/
24861
24862 #if defined( VK_USE_PLATFORM_FUCHSIA )
24863 //=== VK_FUCHSIA_buffer_collection ===
24864
24865 // wrapper function for command vkCreateBufferCollectionFUCHSIA, see
24866 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBufferCollectionFUCHSIA.html
24867 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
24868 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createBufferCollectionFUCHSIA( const BufferCollectionCreateInfoFUCHSIA * pCreateInfo,
24869 const AllocationCallbacks * pAllocator,
24870 BufferCollectionFUCHSIA * pCollection,
24871 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
24872 {
24873 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
24874 return static_cast<Result>( d.vkCreateBufferCollectionFUCHSIA( static_cast<VkDevice>( m_device ),
24875 reinterpret_cast<const VkBufferCollectionCreateInfoFUCHSIA *>( pCreateInfo ),
24876 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
24877 reinterpret_cast<VkBufferCollectionFUCHSIA *>( pCollection ) ) );
24878 }
24879
24880 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
24881 // wrapper function for command vkCreateBufferCollectionFUCHSIA, see
24882 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBufferCollectionFUCHSIA.html
24883 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
24884 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<BufferCollectionFUCHSIA>::type Device::createBufferCollectionFUCHSIA(
24885 const BufferCollectionCreateInfoFUCHSIA & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
24886 {
24887 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
24888 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
24889 VULKAN_HPP_ASSERT( d.vkCreateBufferCollectionFUCHSIA && "Function <vkCreateBufferCollectionFUCHSIA> requires <VK_FUCHSIA_buffer_collection>" );
24890 # endif
24891
24892 BufferCollectionFUCHSIA collection;
24893 Result result = static_cast<Result>( d.vkCreateBufferCollectionFUCHSIA( m_device,
24894 reinterpret_cast<const VkBufferCollectionCreateInfoFUCHSIA *>( &createInfo ),
24895 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
24896 reinterpret_cast<VkBufferCollectionFUCHSIA *>( &collection ) ) );
24897 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createBufferCollectionFUCHSIA" );
24898
24899 return detail::createResultValueType( result, std::move( collection ) );
24900 }
24901
24902 # ifndef VULKAN_HPP_NO_SMART_HANDLE
24903 // wrapper function for command vkCreateBufferCollectionFUCHSIA, see
24904 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBufferCollectionFUCHSIA.html
24905 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
24906 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<BufferCollectionFUCHSIA, Dispatch>>::type
24907 Device::createBufferCollectionFUCHSIAUnique( const BufferCollectionCreateInfoFUCHSIA & createInfo,
24908 Optional<const AllocationCallbacks> allocator,
24909 Dispatch const & d ) const
24910 {
24911 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
24912 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
24913 VULKAN_HPP_ASSERT( d.vkCreateBufferCollectionFUCHSIA && "Function <vkCreateBufferCollectionFUCHSIA> requires <VK_FUCHSIA_buffer_collection>" );
24914 # endif
24915
24916 BufferCollectionFUCHSIA collection;
24917 Result result = static_cast<Result>( d.vkCreateBufferCollectionFUCHSIA( m_device,
24918 reinterpret_cast<const VkBufferCollectionCreateInfoFUCHSIA *>( &createInfo ),
24919 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
24920 reinterpret_cast<VkBufferCollectionFUCHSIA *>( &collection ) ) );
24921 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createBufferCollectionFUCHSIAUnique" );
24922
24923 return detail::createResultValueType(
24924 result, UniqueHandle<BufferCollectionFUCHSIA, Dispatch>( collection, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
24925 }
24926 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
24927 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
24928
24929 // wrapper function for command vkSetBufferCollectionImageConstraintsFUCHSIA, see
24930 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetBufferCollectionImageConstraintsFUCHSIA.html
24931 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
24932 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::setBufferCollectionImageConstraintsFUCHSIA( BufferCollectionFUCHSIA collection,
24933 const ImageConstraintsInfoFUCHSIA * pImageConstraintsInfo,
24934 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
24935 {
24936 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
24937 return static_cast<Result>(
24938 d.vkSetBufferCollectionImageConstraintsFUCHSIA( static_cast<VkDevice>( m_device ),
24939 static_cast<VkBufferCollectionFUCHSIA>( collection ),
24940 reinterpret_cast<const VkImageConstraintsInfoFUCHSIA *>( pImageConstraintsInfo ) ) );
24941 }
24942
24943 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
24944 // wrapper function for command vkSetBufferCollectionImageConstraintsFUCHSIA, see
24945 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetBufferCollectionImageConstraintsFUCHSIA.html
24946 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
24947 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::setBufferCollectionImageConstraintsFUCHSIA(
24948 BufferCollectionFUCHSIA collection, const ImageConstraintsInfoFUCHSIA & imageConstraintsInfo, Dispatch const & d ) const
24949 {
24950 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
24951 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
24952 VULKAN_HPP_ASSERT( d.vkSetBufferCollectionImageConstraintsFUCHSIA &&
24953 "Function <vkSetBufferCollectionImageConstraintsFUCHSIA> requires <VK_FUCHSIA_buffer_collection>" );
24954 # endif
24955
24956 Result result = static_cast<Result>( d.vkSetBufferCollectionImageConstraintsFUCHSIA(
24957 m_device, static_cast<VkBufferCollectionFUCHSIA>( collection ), reinterpret_cast<const VkImageConstraintsInfoFUCHSIA *>( &imageConstraintsInfo ) ) );
24958 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setBufferCollectionImageConstraintsFUCHSIA" );
24959
24960 return detail::createResultValueType( result );
24961 }
24962 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
24963
24964 // wrapper function for command vkSetBufferCollectionBufferConstraintsFUCHSIA, see
24965 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetBufferCollectionBufferConstraintsFUCHSIA.html
24966 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
24967 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::setBufferCollectionBufferConstraintsFUCHSIA(
24968 BufferCollectionFUCHSIA collection, const BufferConstraintsInfoFUCHSIA * pBufferConstraintsInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
24969 {
24970 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
24971 return static_cast<Result>(
24972 d.vkSetBufferCollectionBufferConstraintsFUCHSIA( static_cast<VkDevice>( m_device ),
24973 static_cast<VkBufferCollectionFUCHSIA>( collection ),
24974 reinterpret_cast<const VkBufferConstraintsInfoFUCHSIA *>( pBufferConstraintsInfo ) ) );
24975 }
24976
24977 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
24978 // wrapper function for command vkSetBufferCollectionBufferConstraintsFUCHSIA, see
24979 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetBufferCollectionBufferConstraintsFUCHSIA.html
24980 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
24981 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::setBufferCollectionBufferConstraintsFUCHSIA(
24982 BufferCollectionFUCHSIA collection, const BufferConstraintsInfoFUCHSIA & bufferConstraintsInfo, Dispatch const & d ) const
24983 {
24984 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
24985 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
24986 VULKAN_HPP_ASSERT( d.vkSetBufferCollectionBufferConstraintsFUCHSIA &&
24987 "Function <vkSetBufferCollectionBufferConstraintsFUCHSIA> requires <VK_FUCHSIA_buffer_collection>" );
24988 # endif
24989
24990 Result result = static_cast<Result>( d.vkSetBufferCollectionBufferConstraintsFUCHSIA(
24991 m_device, static_cast<VkBufferCollectionFUCHSIA>( collection ), reinterpret_cast<const VkBufferConstraintsInfoFUCHSIA *>( &bufferConstraintsInfo ) ) );
24992 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setBufferCollectionBufferConstraintsFUCHSIA" );
24993
24994 return detail::createResultValueType( result );
24995 }
24996 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
24997
24998 // wrapper function for command vkDestroyBufferCollectionFUCHSIA, see
24999 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBufferCollectionFUCHSIA.html
25000 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
25001 VULKAN_HPP_INLINE void Device::destroyBufferCollectionFUCHSIA( BufferCollectionFUCHSIA collection,
25002 const AllocationCallbacks * pAllocator,
25003 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
25004 {
25005 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
25006 d.vkDestroyBufferCollectionFUCHSIA(
25007 static_cast<VkDevice>( m_device ), static_cast<VkBufferCollectionFUCHSIA>( collection ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
25008 }
25009
25010 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
25011 // wrapper function for command vkDestroyBufferCollectionFUCHSIA, see
25012 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBufferCollectionFUCHSIA.html
25013 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
25014 VULKAN_HPP_INLINE void Device::destroyBufferCollectionFUCHSIA( BufferCollectionFUCHSIA collection,
25015 Optional<const AllocationCallbacks> allocator,
25016 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
25017 {
25018 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
25019 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
25020 VULKAN_HPP_ASSERT( d.vkDestroyBufferCollectionFUCHSIA && "Function <vkDestroyBufferCollectionFUCHSIA> requires <VK_FUCHSIA_buffer_collection>" );
25021 # endif
25022
25023 d.vkDestroyBufferCollectionFUCHSIA(
25024 m_device, static_cast<VkBufferCollectionFUCHSIA>( collection ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
25025 }
25026 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
25027
25028 // wrapper function for command vkDestroyBufferCollectionFUCHSIA, see
25029 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBufferCollectionFUCHSIA.html
25030 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
25031 VULKAN_HPP_INLINE void
25032 Device::destroy( BufferCollectionFUCHSIA collection, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
25033 {
25034 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
25035 d.vkDestroyBufferCollectionFUCHSIA(
25036 static_cast<VkDevice>( m_device ), static_cast<VkBufferCollectionFUCHSIA>( collection ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
25037 }
25038
25039 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
25040 // wrapper function for command vkDestroyBufferCollectionFUCHSIA, see
25041 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBufferCollectionFUCHSIA.html
25042 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
25043 VULKAN_HPP_INLINE void
25044 Device::destroy( BufferCollectionFUCHSIA collection, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
25045 {
25046 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
25047 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
25048 VULKAN_HPP_ASSERT( d.vkDestroyBufferCollectionFUCHSIA && "Function <vkDestroyBufferCollectionFUCHSIA> requires <VK_FUCHSIA_buffer_collection>" );
25049 # endif
25050
25051 d.vkDestroyBufferCollectionFUCHSIA(
25052 m_device, static_cast<VkBufferCollectionFUCHSIA>( collection ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
25053 }
25054 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
25055
25056 // wrapper function for command vkGetBufferCollectionPropertiesFUCHSIA, see
25057 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferCollectionPropertiesFUCHSIA.html
25058 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
25059 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getBufferCollectionPropertiesFUCHSIA( BufferCollectionFUCHSIA collection,
25060 BufferCollectionPropertiesFUCHSIA * pProperties,
25061 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
25062 {
25063 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
25064 return static_cast<Result>( d.vkGetBufferCollectionPropertiesFUCHSIA( static_cast<VkDevice>( m_device ),
25065 static_cast<VkBufferCollectionFUCHSIA>( collection ),
25066 reinterpret_cast<VkBufferCollectionPropertiesFUCHSIA *>( pProperties ) ) );
25067 }
25068
25069 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
25070 // wrapper function for command vkGetBufferCollectionPropertiesFUCHSIA, see
25071 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferCollectionPropertiesFUCHSIA.html
25072 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
25073 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<BufferCollectionPropertiesFUCHSIA>::type
25074 Device::getBufferCollectionPropertiesFUCHSIA( BufferCollectionFUCHSIA collection, Dispatch const & d ) const
25075 {
25076 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
25077 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
25078 VULKAN_HPP_ASSERT( d.vkGetBufferCollectionPropertiesFUCHSIA &&
25079 "Function <vkGetBufferCollectionPropertiesFUCHSIA> requires <VK_FUCHSIA_buffer_collection>" );
25080 # endif
25081
25082 BufferCollectionPropertiesFUCHSIA properties;
25083 Result result = static_cast<Result>( d.vkGetBufferCollectionPropertiesFUCHSIA(
25084 m_device, static_cast<VkBufferCollectionFUCHSIA>( collection ), reinterpret_cast<VkBufferCollectionPropertiesFUCHSIA *>( &properties ) ) );
25085 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getBufferCollectionPropertiesFUCHSIA" );
25086
25087 return detail::createResultValueType( result, std::move( properties ) );
25088 }
25089 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
25090 #endif /*VK_USE_PLATFORM_FUCHSIA*/
25091
25092 //=== VK_HUAWEI_subpass_shading ===
25093
25094 // wrapper function for command vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI, see
25095 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI.html
25096 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
25097 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSubpassShadingMaxWorkgroupSizeHUAWEI( RenderPass renderpass,
25098 Extent2D * pMaxWorkgroupSize,
25099 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
25100 {
25101 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
25102 return static_cast<Result>( d.vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(
25103 static_cast<VkDevice>( m_device ), static_cast<VkRenderPass>( renderpass ), reinterpret_cast<VkExtent2D *>( pMaxWorkgroupSize ) ) );
25104 }
25105
25106 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
25107 // wrapper function for command vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI, see
25108 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI.html
25109 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
25110 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<Extent2D>::type Device::getSubpassShadingMaxWorkgroupSizeHUAWEI( RenderPass renderpass,
25111 Dispatch const & d ) const
25112 {
25113 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
25114 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
25115 VULKAN_HPP_ASSERT( d.vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI &&
25116 "Function <vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI> requires <VK_HUAWEI_subpass_shading>" );
25117 # endif
25118
25119 Extent2D maxWorkgroupSize;
25120 Result result = static_cast<Result>( d.vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(
25121 m_device, static_cast<VkRenderPass>( renderpass ), reinterpret_cast<VkExtent2D *>( &maxWorkgroupSize ) ) );
25122 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSubpassShadingMaxWorkgroupSizeHUAWEI" );
25123
25124 return detail::createResultValueType( result, std::move( maxWorkgroupSize ) );
25125 }
25126 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
25127
25128 // wrapper function for command vkCmdSubpassShadingHUAWEI, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSubpassShadingHUAWEI.html
25129 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
25130 VULKAN_HPP_INLINE void CommandBuffer::subpassShadingHUAWEI( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
25131 {
25132 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
25133 d.vkCmdSubpassShadingHUAWEI( static_cast<VkCommandBuffer>( m_commandBuffer ) );
25134 }
25135
25136 //=== VK_HUAWEI_invocation_mask ===
25137
25138 // wrapper function for command vkCmdBindInvocationMaskHUAWEI, see
25139 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindInvocationMaskHUAWEI.html
25140 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
25141 VULKAN_HPP_INLINE void CommandBuffer::bindInvocationMaskHUAWEI( ImageView imageView, ImageLayout imageLayout, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
25142 {
25143 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
25144 d.vkCmdBindInvocationMaskHUAWEI(
25145 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkImageView>( imageView ), static_cast<VkImageLayout>( imageLayout ) );
25146 }
25147
25148 //=== VK_NV_external_memory_rdma ===
25149
25150 // wrapper function for command vkGetMemoryRemoteAddressNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryRemoteAddressNV.html
25151 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
25152 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getMemoryRemoteAddressNV( const MemoryGetRemoteAddressInfoNV * pMemoryGetRemoteAddressInfo,
25153 RemoteAddressNV * pAddress,
25154 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
25155 {
25156 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
25157 return static_cast<Result>( d.vkGetMemoryRemoteAddressNV( static_cast<VkDevice>( m_device ),
25158 reinterpret_cast<const VkMemoryGetRemoteAddressInfoNV *>( pMemoryGetRemoteAddressInfo ),
25159 reinterpret_cast<VkRemoteAddressNV *>( pAddress ) ) );
25160 }
25161
25162 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
25163 // wrapper function for command vkGetMemoryRemoteAddressNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryRemoteAddressNV.html
25164 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
25165 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<RemoteAddressNV>::type
25166 Device::getMemoryRemoteAddressNV( const MemoryGetRemoteAddressInfoNV & memoryGetRemoteAddressInfo, Dispatch const & d ) const
25167 {
25168 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
25169 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
25170 VULKAN_HPP_ASSERT( d.vkGetMemoryRemoteAddressNV && "Function <vkGetMemoryRemoteAddressNV> requires <VK_NV_external_memory_rdma>" );
25171 # endif
25172
25173 RemoteAddressNV address;
25174 Result result = static_cast<Result>( d.vkGetMemoryRemoteAddressNV(
25175 m_device, reinterpret_cast<const VkMemoryGetRemoteAddressInfoNV *>( &memoryGetRemoteAddressInfo ), reinterpret_cast<VkRemoteAddressNV *>( &address ) ) );
25176 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryRemoteAddressNV" );
25177
25178 return detail::createResultValueType( result, std::move( address ) );
25179 }
25180 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
25181
25182 //=== VK_EXT_pipeline_properties ===
25183
25184 // wrapper function for command vkGetPipelinePropertiesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelinePropertiesEXT.html
25185 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
25186 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getPipelinePropertiesEXT( const PipelineInfoEXT * pPipelineInfo,
25187 BaseOutStructure * pPipelineProperties,
25188 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
25189 {
25190 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
25191 return static_cast<Result>( d.vkGetPipelinePropertiesEXT( static_cast<VkDevice>( m_device ),
25192 reinterpret_cast<const VkPipelineInfoEXT *>( pPipelineInfo ),
25193 reinterpret_cast<VkBaseOutStructure *>( pPipelineProperties ) ) );
25194 }
25195
25196 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
25197 // wrapper function for command vkGetPipelinePropertiesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelinePropertiesEXT.html
25198 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
25199 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<BaseOutStructure>::type
25200 Device::getPipelinePropertiesEXT( const PipelineInfoEXT & pipelineInfo, Dispatch const & d ) const
25201 {
25202 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
25203 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
25204 VULKAN_HPP_ASSERT( d.vkGetPipelinePropertiesEXT && "Function <vkGetPipelinePropertiesEXT> requires <VK_EXT_pipeline_properties>" );
25205 # endif
25206
25207 BaseOutStructure pipelineProperties;
25208 Result result = static_cast<Result>( d.vkGetPipelinePropertiesEXT(
25209 m_device, reinterpret_cast<const VkPipelineInfoEXT *>( &pipelineInfo ), reinterpret_cast<VkBaseOutStructure *>( &pipelineProperties ) ) );
25210 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelinePropertiesEXT" );
25211
25212 return detail::createResultValueType( result, std::move( pipelineProperties ) );
25213 }
25214 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
25215
25216 //=== VK_EXT_extended_dynamic_state2 ===
25217
25218 // wrapper function for command vkCmdSetPatchControlPointsEXT, see
25219 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPatchControlPointsEXT.html
25220 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
25221 VULKAN_HPP_INLINE void CommandBuffer::setPatchControlPointsEXT( uint32_t patchControlPoints, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
25222 {
25223 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
25224 d.vkCmdSetPatchControlPointsEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), patchControlPoints );
25225 }
25226
25227 // wrapper function for command vkCmdSetRasterizerDiscardEnableEXT, see
25228 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRasterizerDiscardEnableEXT.html
25229 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
25230 VULKAN_HPP_INLINE void CommandBuffer::setRasterizerDiscardEnableEXT( Bool32 rasterizerDiscardEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
25231 {
25232 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
25233 d.vkCmdSetRasterizerDiscardEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( rasterizerDiscardEnable ) );
25234 }
25235
25236 // wrapper function for command vkCmdSetDepthBiasEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBiasEnableEXT.html
25237 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
25238 VULKAN_HPP_INLINE void CommandBuffer::setDepthBiasEnableEXT( Bool32 depthBiasEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
25239 {
25240 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
25241 d.vkCmdSetDepthBiasEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( depthBiasEnable ) );
25242 }
25243
25244 // wrapper function for command vkCmdSetLogicOpEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLogicOpEXT.html
25245 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
25246 VULKAN_HPP_INLINE void CommandBuffer::setLogicOpEXT( LogicOp logicOp, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
25247 {
25248 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
25249 d.vkCmdSetLogicOpEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkLogicOp>( logicOp ) );
25250 }
25251
25252 // wrapper function for command vkCmdSetPrimitiveRestartEnableEXT, see
25253 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPrimitiveRestartEnableEXT.html
25254 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
25255 VULKAN_HPP_INLINE void CommandBuffer::setPrimitiveRestartEnableEXT( Bool32 primitiveRestartEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
25256 {
25257 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
25258 d.vkCmdSetPrimitiveRestartEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( primitiveRestartEnable ) );
25259 }
25260
25261 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
25262 //=== VK_QNX_screen_surface ===
25263
25264 // wrapper function for command vkCreateScreenSurfaceQNX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateScreenSurfaceQNX.html
25265 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
25266 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createScreenSurfaceQNX( const ScreenSurfaceCreateInfoQNX * pCreateInfo,
25267 const AllocationCallbacks * pAllocator,
25268 SurfaceKHR * pSurface,
25269 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
25270 {
25271 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
25272 return static_cast<Result>( d.vkCreateScreenSurfaceQNX( static_cast<VkInstance>( m_instance ),
25273 reinterpret_cast<const VkScreenSurfaceCreateInfoQNX *>( pCreateInfo ),
25274 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
25275 reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) );
25276 }
25277
25278 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
25279 // wrapper function for command vkCreateScreenSurfaceQNX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateScreenSurfaceQNX.html
25280 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
25281 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<SurfaceKHR>::type
25282 Instance::createScreenSurfaceQNX( const ScreenSurfaceCreateInfoQNX & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
25283 {
25284 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
25285 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
25286 VULKAN_HPP_ASSERT( d.vkCreateScreenSurfaceQNX && "Function <vkCreateScreenSurfaceQNX> requires <VK_QNX_screen_surface>" );
25287 # endif
25288
25289 SurfaceKHR surface;
25290 Result result = static_cast<Result>( d.vkCreateScreenSurfaceQNX( m_instance,
25291 reinterpret_cast<const VkScreenSurfaceCreateInfoQNX *>( &createInfo ),
25292 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
25293 reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
25294 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createScreenSurfaceQNX" );
25295
25296 return detail::createResultValueType( result, std::move( surface ) );
25297 }
25298
25299 # ifndef VULKAN_HPP_NO_SMART_HANDLE
25300 // wrapper function for command vkCreateScreenSurfaceQNX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateScreenSurfaceQNX.html
25301 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
25302 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type Instance::createScreenSurfaceQNXUnique(
25303 const ScreenSurfaceCreateInfoQNX & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
25304 {
25305 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
25306 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
25307 VULKAN_HPP_ASSERT( d.vkCreateScreenSurfaceQNX && "Function <vkCreateScreenSurfaceQNX> requires <VK_QNX_screen_surface>" );
25308 # endif
25309
25310 SurfaceKHR surface;
25311 Result result = static_cast<Result>( d.vkCreateScreenSurfaceQNX( m_instance,
25312 reinterpret_cast<const VkScreenSurfaceCreateInfoQNX *>( &createInfo ),
25313 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
25314 reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
25315 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createScreenSurfaceQNXUnique" );
25316
25317 return detail::createResultValueType( result,
25318 UniqueHandle<SurfaceKHR, Dispatch>( surface, detail::ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) );
25319 }
25320 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
25321 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
25322
25323 // wrapper function for command vkGetPhysicalDeviceScreenPresentationSupportQNX, see
25324 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceScreenPresentationSupportQNX.html
25325 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
25326 VULKAN_HPP_INLINE Bool32 PhysicalDevice::getScreenPresentationSupportQNX( uint32_t queueFamilyIndex,
25327 struct _screen_window * window,
25328 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
25329 {
25330 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
25331 return static_cast<Bool32>(
25332 d.vkGetPhysicalDeviceScreenPresentationSupportQNX( static_cast<VkPhysicalDevice>( m_physicalDevice ), queueFamilyIndex, window ) );
25333 }
25334
25335 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
25336 // wrapper function for command vkGetPhysicalDeviceScreenPresentationSupportQNX, see
25337 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceScreenPresentationSupportQNX.html
25338 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
25339 VULKAN_HPP_INLINE Bool32 PhysicalDevice::getScreenPresentationSupportQNX( uint32_t queueFamilyIndex,
25340 struct _screen_window & window,
25341 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
25342 {
25343 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
25344 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
25345 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceScreenPresentationSupportQNX &&
25346 "Function <vkGetPhysicalDeviceScreenPresentationSupportQNX> requires <VK_QNX_screen_surface>" );
25347 # endif
25348
25349 VkBool32 result = d.vkGetPhysicalDeviceScreenPresentationSupportQNX( m_physicalDevice, queueFamilyIndex, &window );
25350
25351 return static_cast<Bool32>( result );
25352 }
25353 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
25354 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
25355
25356 //=== VK_EXT_color_write_enable ===
25357
25358 // wrapper function for command vkCmdSetColorWriteEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorWriteEnableEXT.html
25359 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
25360 VULKAN_HPP_INLINE void
25361 CommandBuffer::setColorWriteEnableEXT( uint32_t attachmentCount, const Bool32 * pColorWriteEnables, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
25362 {
25363 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
25364 d.vkCmdSetColorWriteEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), attachmentCount, reinterpret_cast<const VkBool32 *>( pColorWriteEnables ) );
25365 }
25366
25367 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
25368 // wrapper function for command vkCmdSetColorWriteEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorWriteEnableEXT.html
25369 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
25370 VULKAN_HPP_INLINE void CommandBuffer::setColorWriteEnableEXT( ArrayProxy<const Bool32> const & colorWriteEnables,
25371 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
25372 {
25373 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
25374 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
25375 VULKAN_HPP_ASSERT( d.vkCmdSetColorWriteEnableEXT && "Function <vkCmdSetColorWriteEnableEXT> requires <VK_EXT_color_write_enable>" );
25376 # endif
25377
25378 d.vkCmdSetColorWriteEnableEXT( m_commandBuffer, colorWriteEnables.size(), reinterpret_cast<const VkBool32 *>( colorWriteEnables.data() ) );
25379 }
25380 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
25381
25382 //=== VK_KHR_ray_tracing_maintenance1 ===
25383
25384 // wrapper function for command vkCmdTraceRaysIndirect2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdTraceRaysIndirect2KHR.html
25385 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
25386 VULKAN_HPP_INLINE void CommandBuffer::traceRaysIndirect2KHR( DeviceAddress indirectDeviceAddress, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
25387 {
25388 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
25389 d.vkCmdTraceRaysIndirect2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkDeviceAddress>( indirectDeviceAddress ) );
25390 }
25391
25392 //=== VK_EXT_multi_draw ===
25393
25394 // wrapper function for command vkCmdDrawMultiEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMultiEXT.html
25395 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
25396 VULKAN_HPP_INLINE void CommandBuffer::drawMultiEXT( uint32_t drawCount,
25397 const MultiDrawInfoEXT * pVertexInfo,
25398 uint32_t instanceCount,
25399 uint32_t firstInstance,
25400 uint32_t stride,
25401 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
25402 {
25403 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
25404 d.vkCmdDrawMultiEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
25405 drawCount,
25406 reinterpret_cast<const VkMultiDrawInfoEXT *>( pVertexInfo ),
25407 instanceCount,
25408 firstInstance,
25409 stride );
25410 }
25411
25412 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
25413 // wrapper function for command vkCmdDrawMultiEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMultiEXT.html
25414 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
25415 VULKAN_HPP_INLINE void CommandBuffer::drawMultiEXT( StridedArrayProxy<const MultiDrawInfoEXT> const & vertexInfo,
25416 uint32_t instanceCount,
25417 uint32_t firstInstance,
25418 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
25419 {
25420 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
25421 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
25422 VULKAN_HPP_ASSERT( d.vkCmdDrawMultiEXT && "Function <vkCmdDrawMultiEXT> requires <VK_EXT_multi_draw>" );
25423 # endif
25424
25425 d.vkCmdDrawMultiEXT( m_commandBuffer,
25426 vertexInfo.size(),
25427 reinterpret_cast<const VkMultiDrawInfoEXT *>( vertexInfo.data() ),
25428 instanceCount,
25429 firstInstance,
25430 vertexInfo.stride() );
25431 }
25432 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
25433
25434 // wrapper function for command vkCmdDrawMultiIndexedEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMultiIndexedEXT.html
25435 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
25436 VULKAN_HPP_INLINE void CommandBuffer::drawMultiIndexedEXT( uint32_t drawCount,
25437 const MultiDrawIndexedInfoEXT * pIndexInfo,
25438 uint32_t instanceCount,
25439 uint32_t firstInstance,
25440 uint32_t stride,
25441 const int32_t * pVertexOffset,
25442 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
25443 {
25444 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
25445 d.vkCmdDrawMultiIndexedEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
25446 drawCount,
25447 reinterpret_cast<const VkMultiDrawIndexedInfoEXT *>( pIndexInfo ),
25448 instanceCount,
25449 firstInstance,
25450 stride,
25451 pVertexOffset );
25452 }
25453
25454 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
25455 // wrapper function for command vkCmdDrawMultiIndexedEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMultiIndexedEXT.html
25456 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
25457 VULKAN_HPP_INLINE void CommandBuffer::drawMultiIndexedEXT( StridedArrayProxy<const MultiDrawIndexedInfoEXT> const & indexInfo,
25458 uint32_t instanceCount,
25459 uint32_t firstInstance,
25460 Optional<const int32_t> vertexOffset,
25461 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
25462 {
25463 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
25464 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
25465 VULKAN_HPP_ASSERT( d.vkCmdDrawMultiIndexedEXT && "Function <vkCmdDrawMultiIndexedEXT> requires <VK_EXT_multi_draw>" );
25466 # endif
25467
25468 d.vkCmdDrawMultiIndexedEXT( m_commandBuffer,
25469 indexInfo.size(),
25470 reinterpret_cast<const VkMultiDrawIndexedInfoEXT *>( indexInfo.data() ),
25471 instanceCount,
25472 firstInstance,
25473 indexInfo.stride(),
25474 vertexOffset.get() );
25475 }
25476 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
25477
25478 //=== VK_EXT_opacity_micromap ===
25479
25480 // wrapper function for command vkCreateMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMicromapEXT.html
25481 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
25482 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createMicromapEXT( const MicromapCreateInfoEXT * pCreateInfo,
25483 const AllocationCallbacks * pAllocator,
25484 MicromapEXT * pMicromap,
25485 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
25486 {
25487 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
25488 return static_cast<Result>( d.vkCreateMicromapEXT( static_cast<VkDevice>( m_device ),
25489 reinterpret_cast<const VkMicromapCreateInfoEXT *>( pCreateInfo ),
25490 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
25491 reinterpret_cast<VkMicromapEXT *>( pMicromap ) ) );
25492 }
25493
25494 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
25495 // wrapper function for command vkCreateMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMicromapEXT.html
25496 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
25497 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<MicromapEXT>::type
25498 Device::createMicromapEXT( const MicromapCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
25499 {
25500 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
25501 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
25502 VULKAN_HPP_ASSERT( d.vkCreateMicromapEXT && "Function <vkCreateMicromapEXT> requires <VK_EXT_opacity_micromap>" );
25503 # endif
25504
25505 MicromapEXT micromap;
25506 Result result = static_cast<Result>( d.vkCreateMicromapEXT( m_device,
25507 reinterpret_cast<const VkMicromapCreateInfoEXT *>( &createInfo ),
25508 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
25509 reinterpret_cast<VkMicromapEXT *>( &micromap ) ) );
25510 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createMicromapEXT" );
25511
25512 return detail::createResultValueType( result, std::move( micromap ) );
25513 }
25514
25515 # ifndef VULKAN_HPP_NO_SMART_HANDLE
25516 // wrapper function for command vkCreateMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMicromapEXT.html
25517 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
25518 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<MicromapEXT, Dispatch>>::type
25519 Device::createMicromapEXTUnique( const MicromapCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
25520 {
25521 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
25522 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
25523 VULKAN_HPP_ASSERT( d.vkCreateMicromapEXT && "Function <vkCreateMicromapEXT> requires <VK_EXT_opacity_micromap>" );
25524 # endif
25525
25526 MicromapEXT micromap;
25527 Result result = static_cast<Result>( d.vkCreateMicromapEXT( m_device,
25528 reinterpret_cast<const VkMicromapCreateInfoEXT *>( &createInfo ),
25529 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
25530 reinterpret_cast<VkMicromapEXT *>( &micromap ) ) );
25531 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createMicromapEXTUnique" );
25532
25533 return detail::createResultValueType( result,
25534 UniqueHandle<MicromapEXT, Dispatch>( micromap, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
25535 }
25536 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
25537 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
25538
25539 // wrapper function for command vkDestroyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyMicromapEXT.html
25540 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
25541 VULKAN_HPP_INLINE void
25542 Device::destroyMicromapEXT( MicromapEXT micromap, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
25543 {
25544 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
25545 d.vkDestroyMicromapEXT(
25546 static_cast<VkDevice>( m_device ), static_cast<VkMicromapEXT>( micromap ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
25547 }
25548
25549 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
25550 // wrapper function for command vkDestroyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyMicromapEXT.html
25551 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
25552 VULKAN_HPP_INLINE void
25553 Device::destroyMicromapEXT( MicromapEXT micromap, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
25554 {
25555 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
25556 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
25557 VULKAN_HPP_ASSERT( d.vkDestroyMicromapEXT && "Function <vkDestroyMicromapEXT> requires <VK_EXT_opacity_micromap>" );
25558 # endif
25559
25560 d.vkDestroyMicromapEXT( m_device, static_cast<VkMicromapEXT>( micromap ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
25561 }
25562 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
25563
25564 // wrapper function for command vkDestroyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyMicromapEXT.html
25565 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
25566 VULKAN_HPP_INLINE void Device::destroy( MicromapEXT micromap, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
25567 {
25568 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
25569 d.vkDestroyMicromapEXT(
25570 static_cast<VkDevice>( m_device ), static_cast<VkMicromapEXT>( micromap ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
25571 }
25572
25573 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
25574 // wrapper function for command vkDestroyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyMicromapEXT.html
25575 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
25576 VULKAN_HPP_INLINE void Device::destroy( MicromapEXT micromap, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
25577 {
25578 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
25579 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
25580 VULKAN_HPP_ASSERT( d.vkDestroyMicromapEXT && "Function <vkDestroyMicromapEXT> requires <VK_EXT_opacity_micromap>" );
25581 # endif
25582
25583 d.vkDestroyMicromapEXT( m_device, static_cast<VkMicromapEXT>( micromap ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
25584 }
25585 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
25586
25587 // wrapper function for command vkCmdBuildMicromapsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildMicromapsEXT.html
25588 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
25589 VULKAN_HPP_INLINE void
25590 CommandBuffer::buildMicromapsEXT( uint32_t infoCount, const MicromapBuildInfoEXT * pInfos, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
25591 {
25592 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
25593 d.vkCmdBuildMicromapsEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), infoCount, reinterpret_cast<const VkMicromapBuildInfoEXT *>( pInfos ) );
25594 }
25595
25596 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
25597 // wrapper function for command vkCmdBuildMicromapsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildMicromapsEXT.html
25598 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
25599 VULKAN_HPP_INLINE void CommandBuffer::buildMicromapsEXT( ArrayProxy<const MicromapBuildInfoEXT> const & infos, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
25600 {
25601 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
25602 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
25603 VULKAN_HPP_ASSERT( d.vkCmdBuildMicromapsEXT && "Function <vkCmdBuildMicromapsEXT> requires <VK_EXT_opacity_micromap>" );
25604 # endif
25605
25606 d.vkCmdBuildMicromapsEXT( m_commandBuffer, infos.size(), reinterpret_cast<const VkMicromapBuildInfoEXT *>( infos.data() ) );
25607 }
25608 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
25609
25610 // wrapper function for command vkBuildMicromapsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBuildMicromapsEXT.html
25611 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
25612 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::buildMicromapsEXT( DeferredOperationKHR deferredOperation,
25613 uint32_t infoCount,
25614 const MicromapBuildInfoEXT * pInfos,
25615 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
25616 {
25617 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
25618 return static_cast<Result>( d.vkBuildMicromapsEXT( static_cast<VkDevice>( m_device ),
25619 static_cast<VkDeferredOperationKHR>( deferredOperation ),
25620 infoCount,
25621 reinterpret_cast<const VkMicromapBuildInfoEXT *>( pInfos ) ) );
25622 }
25623
25624 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
25625 // wrapper function for command vkBuildMicromapsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBuildMicromapsEXT.html
25626 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
25627 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::buildMicromapsEXT( DeferredOperationKHR deferredOperation,
25628 ArrayProxy<const MicromapBuildInfoEXT> const & infos,
25629 Dispatch const & d ) const
25630 {
25631 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
25632 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
25633 VULKAN_HPP_ASSERT( d.vkBuildMicromapsEXT && "Function <vkBuildMicromapsEXT> requires <VK_EXT_opacity_micromap>" );
25634 # endif
25635
25636 Result result = static_cast<Result>( d.vkBuildMicromapsEXT(
25637 m_device, static_cast<VkDeferredOperationKHR>( deferredOperation ), infos.size(), reinterpret_cast<const VkMicromapBuildInfoEXT *>( infos.data() ) ) );
25638 detail::resultCheck( result,
25639 VULKAN_HPP_NAMESPACE_STRING "::Device::buildMicromapsEXT",
25640 { Result::eSuccess, Result::eOperationDeferredKHR, Result::eOperationNotDeferredKHR } );
25641
25642 return static_cast<Result>( result );
25643 }
25644 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
25645
25646 // wrapper function for command vkCopyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMicromapEXT.html
25647 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
25648 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyMicromapEXT( DeferredOperationKHR deferredOperation,
25649 const CopyMicromapInfoEXT * pInfo,
25650 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
25651 {
25652 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
25653 return static_cast<Result>( d.vkCopyMicromapEXT(
25654 static_cast<VkDevice>( m_device ), static_cast<VkDeferredOperationKHR>( deferredOperation ), reinterpret_cast<const VkCopyMicromapInfoEXT *>( pInfo ) ) );
25655 }
25656
25657 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
25658 // wrapper function for command vkCopyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMicromapEXT.html
25659 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
25660 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyMicromapEXT( DeferredOperationKHR deferredOperation,
25661 const CopyMicromapInfoEXT & info,
25662 Dispatch const & d ) const
25663 {
25664 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
25665 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
25666 VULKAN_HPP_ASSERT( d.vkCopyMicromapEXT && "Function <vkCopyMicromapEXT> requires <VK_EXT_opacity_micromap>" );
25667 # endif
25668
25669 Result result = static_cast<Result>(
25670 d.vkCopyMicromapEXT( m_device, static_cast<VkDeferredOperationKHR>( deferredOperation ), reinterpret_cast<const VkCopyMicromapInfoEXT *>( &info ) ) );
25671 detail::resultCheck(
25672 result, VULKAN_HPP_NAMESPACE_STRING "::Device::copyMicromapEXT", { Result::eSuccess, Result::eOperationDeferredKHR, Result::eOperationNotDeferredKHR } );
25673
25674 return static_cast<Result>( result );
25675 }
25676 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
25677
25678 // wrapper function for command vkCopyMicromapToMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMicromapToMemoryEXT.html
25679 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
25680 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyMicromapToMemoryEXT( DeferredOperationKHR deferredOperation,
25681 const CopyMicromapToMemoryInfoEXT * pInfo,
25682 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
25683 {
25684 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
25685 return static_cast<Result>( d.vkCopyMicromapToMemoryEXT( static_cast<VkDevice>( m_device ),
25686 static_cast<VkDeferredOperationKHR>( deferredOperation ),
25687 reinterpret_cast<const VkCopyMicromapToMemoryInfoEXT *>( pInfo ) ) );
25688 }
25689
25690 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
25691 // wrapper function for command vkCopyMicromapToMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMicromapToMemoryEXT.html
25692 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
25693 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyMicromapToMemoryEXT( DeferredOperationKHR deferredOperation,
25694 const CopyMicromapToMemoryInfoEXT & info,
25695 Dispatch const & d ) const
25696 {
25697 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
25698 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
25699 VULKAN_HPP_ASSERT( d.vkCopyMicromapToMemoryEXT && "Function <vkCopyMicromapToMemoryEXT> requires <VK_EXT_opacity_micromap>" );
25700 # endif
25701
25702 Result result = static_cast<Result>( d.vkCopyMicromapToMemoryEXT(
25703 m_device, static_cast<VkDeferredOperationKHR>( deferredOperation ), reinterpret_cast<const VkCopyMicromapToMemoryInfoEXT *>( &info ) ) );
25704 detail::resultCheck( result,
25705 VULKAN_HPP_NAMESPACE_STRING "::Device::copyMicromapToMemoryEXT",
25706 { Result::eSuccess, Result::eOperationDeferredKHR, Result::eOperationNotDeferredKHR } );
25707
25708 return static_cast<Result>( result );
25709 }
25710 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
25711
25712 // wrapper function for command vkCopyMemoryToMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToMicromapEXT.html
25713 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
25714 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyMemoryToMicromapEXT( DeferredOperationKHR deferredOperation,
25715 const CopyMemoryToMicromapInfoEXT * pInfo,
25716 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
25717 {
25718 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
25719 return static_cast<Result>( d.vkCopyMemoryToMicromapEXT( static_cast<VkDevice>( m_device ),
25720 static_cast<VkDeferredOperationKHR>( deferredOperation ),
25721 reinterpret_cast<const VkCopyMemoryToMicromapInfoEXT *>( pInfo ) ) );
25722 }
25723
25724 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
25725 // wrapper function for command vkCopyMemoryToMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToMicromapEXT.html
25726 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
25727 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyMemoryToMicromapEXT( DeferredOperationKHR deferredOperation,
25728 const CopyMemoryToMicromapInfoEXT & info,
25729 Dispatch const & d ) const
25730 {
25731 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
25732 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
25733 VULKAN_HPP_ASSERT( d.vkCopyMemoryToMicromapEXT && "Function <vkCopyMemoryToMicromapEXT> requires <VK_EXT_opacity_micromap>" );
25734 # endif
25735
25736 Result result = static_cast<Result>( d.vkCopyMemoryToMicromapEXT(
25737 m_device, static_cast<VkDeferredOperationKHR>( deferredOperation ), reinterpret_cast<const VkCopyMemoryToMicromapInfoEXT *>( &info ) ) );
25738 detail::resultCheck( result,
25739 VULKAN_HPP_NAMESPACE_STRING "::Device::copyMemoryToMicromapEXT",
25740 { Result::eSuccess, Result::eOperationDeferredKHR, Result::eOperationNotDeferredKHR } );
25741
25742 return static_cast<Result>( result );
25743 }
25744 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
25745
25746 // wrapper function for command vkWriteMicromapsPropertiesEXT, see
25747 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteMicromapsPropertiesEXT.html
25748 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
25749 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::writeMicromapsPropertiesEXT( uint32_t micromapCount,
25750 const MicromapEXT * pMicromaps,
25751 QueryType queryType,
25752 size_t dataSize,
25753 void * pData,
25754 size_t stride,
25755 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
25756 {
25757 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
25758 return static_cast<Result>( d.vkWriteMicromapsPropertiesEXT( static_cast<VkDevice>( m_device ),
25759 micromapCount,
25760 reinterpret_cast<const VkMicromapEXT *>( pMicromaps ),
25761 static_cast<VkQueryType>( queryType ),
25762 dataSize,
25763 pData,
25764 stride ) );
25765 }
25766
25767 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
25768 // wrapper function for command vkWriteMicromapsPropertiesEXT, see
25769 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteMicromapsPropertiesEXT.html
25770 template <typename DataType,
25771 typename DataTypeAllocator,
25772 typename Dispatch,
25773 typename std::enable_if<std::is_same<typename DataTypeAllocator::value_type, DataType>::value, int>::type,
25774 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
25775 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type Device::writeMicromapsPropertiesEXT(
25776 ArrayProxy<const MicromapEXT> const & micromaps, QueryType queryType, size_t dataSize, size_t stride, Dispatch const & d ) const
25777 {
25778 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
25779 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
25780 VULKAN_HPP_ASSERT( d.vkWriteMicromapsPropertiesEXT && "Function <vkWriteMicromapsPropertiesEXT> requires <VK_EXT_opacity_micromap>" );
25781 # endif
25782
25783 VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 );
25784 std::vector<DataType, DataTypeAllocator> data( dataSize / sizeof( DataType ) );
25785 Result result = static_cast<Result>( d.vkWriteMicromapsPropertiesEXT( m_device,
25786 micromaps.size(),
25787 reinterpret_cast<const VkMicromapEXT *>( micromaps.data() ),
25788 static_cast<VkQueryType>( queryType ),
25789 data.size() * sizeof( DataType ),
25790 reinterpret_cast<void *>( data.data() ),
25791 stride ) );
25792 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::writeMicromapsPropertiesEXT" );
25793
25794 return detail::createResultValueType( result, std::move( data ) );
25795 }
25796
25797 // wrapper function for command vkWriteMicromapsPropertiesEXT, see
25798 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteMicromapsPropertiesEXT.html
25799 template <typename DataType, typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
25800 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<DataType>::type
25801 Device::writeMicromapsPropertyEXT( ArrayProxy<const MicromapEXT> const & micromaps, QueryType queryType, size_t stride, Dispatch const & d ) const
25802 {
25803 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
25804 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
25805 VULKAN_HPP_ASSERT( d.vkWriteMicromapsPropertiesEXT && "Function <vkWriteMicromapsPropertiesEXT> requires <VK_EXT_opacity_micromap>" );
25806 # endif
25807
25808 DataType data;
25809 Result result = static_cast<Result>( d.vkWriteMicromapsPropertiesEXT( m_device,
25810 micromaps.size(),
25811 reinterpret_cast<const VkMicromapEXT *>( micromaps.data() ),
25812 static_cast<VkQueryType>( queryType ),
25813 sizeof( DataType ),
25814 reinterpret_cast<void *>( &data ),
25815 stride ) );
25816 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::writeMicromapsPropertyEXT" );
25817
25818 return detail::createResultValueType( result, std::move( data ) );
25819 }
25820 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
25821
25822 // wrapper function for command vkCmdCopyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMicromapEXT.html
25823 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
25824 VULKAN_HPP_INLINE void CommandBuffer::copyMicromapEXT( const CopyMicromapInfoEXT * pInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
25825 {
25826 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
25827 d.vkCmdCopyMicromapEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkCopyMicromapInfoEXT *>( pInfo ) );
25828 }
25829
25830 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
25831 // wrapper function for command vkCmdCopyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMicromapEXT.html
25832 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
25833 VULKAN_HPP_INLINE void CommandBuffer::copyMicromapEXT( const CopyMicromapInfoEXT & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
25834 {
25835 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
25836 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
25837 VULKAN_HPP_ASSERT( d.vkCmdCopyMicromapEXT && "Function <vkCmdCopyMicromapEXT> requires <VK_EXT_opacity_micromap>" );
25838 # endif
25839
25840 d.vkCmdCopyMicromapEXT( m_commandBuffer, reinterpret_cast<const VkCopyMicromapInfoEXT *>( &info ) );
25841 }
25842 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
25843
25844 // wrapper function for command vkCmdCopyMicromapToMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMicromapToMemoryEXT.html
25845 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
25846 VULKAN_HPP_INLINE void CommandBuffer::copyMicromapToMemoryEXT( const CopyMicromapToMemoryInfoEXT * pInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
25847 {
25848 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
25849 d.vkCmdCopyMicromapToMemoryEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkCopyMicromapToMemoryInfoEXT *>( pInfo ) );
25850 }
25851
25852 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
25853 // wrapper function for command vkCmdCopyMicromapToMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMicromapToMemoryEXT.html
25854 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
25855 VULKAN_HPP_INLINE void CommandBuffer::copyMicromapToMemoryEXT( const CopyMicromapToMemoryInfoEXT & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
25856 {
25857 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
25858 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
25859 VULKAN_HPP_ASSERT( d.vkCmdCopyMicromapToMemoryEXT && "Function <vkCmdCopyMicromapToMemoryEXT> requires <VK_EXT_opacity_micromap>" );
25860 # endif
25861
25862 d.vkCmdCopyMicromapToMemoryEXT( m_commandBuffer, reinterpret_cast<const VkCopyMicromapToMemoryInfoEXT *>( &info ) );
25863 }
25864 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
25865
25866 // wrapper function for command vkCmdCopyMemoryToMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToMicromapEXT.html
25867 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
25868 VULKAN_HPP_INLINE void CommandBuffer::copyMemoryToMicromapEXT( const CopyMemoryToMicromapInfoEXT * pInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
25869 {
25870 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
25871 d.vkCmdCopyMemoryToMicromapEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkCopyMemoryToMicromapInfoEXT *>( pInfo ) );
25872 }
25873
25874 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
25875 // wrapper function for command vkCmdCopyMemoryToMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToMicromapEXT.html
25876 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
25877 VULKAN_HPP_INLINE void CommandBuffer::copyMemoryToMicromapEXT( const CopyMemoryToMicromapInfoEXT & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
25878 {
25879 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
25880 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
25881 VULKAN_HPP_ASSERT( d.vkCmdCopyMemoryToMicromapEXT && "Function <vkCmdCopyMemoryToMicromapEXT> requires <VK_EXT_opacity_micromap>" );
25882 # endif
25883
25884 d.vkCmdCopyMemoryToMicromapEXT( m_commandBuffer, reinterpret_cast<const VkCopyMemoryToMicromapInfoEXT *>( &info ) );
25885 }
25886 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
25887
25888 // wrapper function for command vkCmdWriteMicromapsPropertiesEXT, see
25889 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteMicromapsPropertiesEXT.html
25890 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
25891 VULKAN_HPP_INLINE void CommandBuffer::writeMicromapsPropertiesEXT( uint32_t micromapCount,
25892 const MicromapEXT * pMicromaps,
25893 QueryType queryType,
25894 QueryPool queryPool,
25895 uint32_t firstQuery,
25896 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
25897 {
25898 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
25899 d.vkCmdWriteMicromapsPropertiesEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
25900 micromapCount,
25901 reinterpret_cast<const VkMicromapEXT *>( pMicromaps ),
25902 static_cast<VkQueryType>( queryType ),
25903 static_cast<VkQueryPool>( queryPool ),
25904 firstQuery );
25905 }
25906
25907 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
25908 // wrapper function for command vkCmdWriteMicromapsPropertiesEXT, see
25909 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteMicromapsPropertiesEXT.html
25910 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
25911 VULKAN_HPP_INLINE void CommandBuffer::writeMicromapsPropertiesEXT( ArrayProxy<const MicromapEXT> const & micromaps,
25912 QueryType queryType,
25913 QueryPool queryPool,
25914 uint32_t firstQuery,
25915 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
25916 {
25917 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
25918 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
25919 VULKAN_HPP_ASSERT( d.vkCmdWriteMicromapsPropertiesEXT && "Function <vkCmdWriteMicromapsPropertiesEXT> requires <VK_EXT_opacity_micromap>" );
25920 # endif
25921
25922 d.vkCmdWriteMicromapsPropertiesEXT( m_commandBuffer,
25923 micromaps.size(),
25924 reinterpret_cast<const VkMicromapEXT *>( micromaps.data() ),
25925 static_cast<VkQueryType>( queryType ),
25926 static_cast<VkQueryPool>( queryPool ),
25927 firstQuery );
25928 }
25929 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
25930
25931 // wrapper function for command vkGetDeviceMicromapCompatibilityEXT, see
25932 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMicromapCompatibilityEXT.html
25933 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
25934 VULKAN_HPP_INLINE void Device::getMicromapCompatibilityEXT( const MicromapVersionInfoEXT * pVersionInfo,
25935 AccelerationStructureCompatibilityKHR * pCompatibility,
25936 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
25937 {
25938 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
25939 d.vkGetDeviceMicromapCompatibilityEXT( static_cast<VkDevice>( m_device ),
25940 reinterpret_cast<const VkMicromapVersionInfoEXT *>( pVersionInfo ),
25941 reinterpret_cast<VkAccelerationStructureCompatibilityKHR *>( pCompatibility ) );
25942 }
25943
25944 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
25945 // wrapper function for command vkGetDeviceMicromapCompatibilityEXT, see
25946 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMicromapCompatibilityEXT.html
25947 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
25948 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE AccelerationStructureCompatibilityKHR
25949 Device::getMicromapCompatibilityEXT( const MicromapVersionInfoEXT & versionInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
25950 {
25951 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
25952 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
25953 VULKAN_HPP_ASSERT( d.vkGetDeviceMicromapCompatibilityEXT && "Function <vkGetDeviceMicromapCompatibilityEXT> requires <VK_EXT_opacity_micromap>" );
25954 # endif
25955
25956 AccelerationStructureCompatibilityKHR compatibility;
25957 d.vkGetDeviceMicromapCompatibilityEXT( m_device,
25958 reinterpret_cast<const VkMicromapVersionInfoEXT *>( &versionInfo ),
25959 reinterpret_cast<VkAccelerationStructureCompatibilityKHR *>( &compatibility ) );
25960
25961 return compatibility;
25962 }
25963 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
25964
25965 // wrapper function for command vkGetMicromapBuildSizesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMicromapBuildSizesEXT.html
25966 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
25967 VULKAN_HPP_INLINE void Device::getMicromapBuildSizesEXT( AccelerationStructureBuildTypeKHR buildType,
25968 const MicromapBuildInfoEXT * pBuildInfo,
25969 MicromapBuildSizesInfoEXT * pSizeInfo,
25970 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
25971 {
25972 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
25973 d.vkGetMicromapBuildSizesEXT( static_cast<VkDevice>( m_device ),
25974 static_cast<VkAccelerationStructureBuildTypeKHR>( buildType ),
25975 reinterpret_cast<const VkMicromapBuildInfoEXT *>( pBuildInfo ),
25976 reinterpret_cast<VkMicromapBuildSizesInfoEXT *>( pSizeInfo ) );
25977 }
25978
25979 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
25980 // wrapper function for command vkGetMicromapBuildSizesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMicromapBuildSizesEXT.html
25981 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
25982 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MicromapBuildSizesInfoEXT Device::getMicromapBuildSizesEXT( AccelerationStructureBuildTypeKHR buildType,
25983 const MicromapBuildInfoEXT & buildInfo,
25984 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
25985 {
25986 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
25987 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
25988 VULKAN_HPP_ASSERT( d.vkGetMicromapBuildSizesEXT && "Function <vkGetMicromapBuildSizesEXT> requires <VK_EXT_opacity_micromap>" );
25989 # endif
25990
25991 MicromapBuildSizesInfoEXT sizeInfo;
25992 d.vkGetMicromapBuildSizesEXT( m_device,
25993 static_cast<VkAccelerationStructureBuildTypeKHR>( buildType ),
25994 reinterpret_cast<const VkMicromapBuildInfoEXT *>( &buildInfo ),
25995 reinterpret_cast<VkMicromapBuildSizesInfoEXT *>( &sizeInfo ) );
25996
25997 return sizeInfo;
25998 }
25999 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
26000
26001 //=== VK_HUAWEI_cluster_culling_shader ===
26002
26003 // wrapper function for command vkCmdDrawClusterHUAWEI, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawClusterHUAWEI.html
26004 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26005 VULKAN_HPP_INLINE void
26006 CommandBuffer::drawClusterHUAWEI( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
26007 {
26008 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26009 d.vkCmdDrawClusterHUAWEI( static_cast<VkCommandBuffer>( m_commandBuffer ), groupCountX, groupCountY, groupCountZ );
26010 }
26011
26012 // wrapper function for command vkCmdDrawClusterIndirectHUAWEI, see
26013 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawClusterIndirectHUAWEI.html
26014 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26015 VULKAN_HPP_INLINE void CommandBuffer::drawClusterIndirectHUAWEI( Buffer buffer, DeviceSize offset, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
26016 {
26017 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26018 d.vkCmdDrawClusterIndirectHUAWEI( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ) );
26019 }
26020
26021 //=== VK_EXT_pageable_device_local_memory ===
26022
26023 // wrapper function for command vkSetDeviceMemoryPriorityEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDeviceMemoryPriorityEXT.html
26024 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26025 VULKAN_HPP_INLINE void Device::setMemoryPriorityEXT( DeviceMemory memory, float priority, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
26026 {
26027 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26028 d.vkSetDeviceMemoryPriorityEXT( static_cast<VkDevice>( m_device ), static_cast<VkDeviceMemory>( memory ), priority );
26029 }
26030
26031 //=== VK_KHR_maintenance4 ===
26032
26033 // wrapper function for command vkGetDeviceBufferMemoryRequirementsKHR, see
26034 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceBufferMemoryRequirementsKHR.html
26035 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26036 VULKAN_HPP_INLINE void Device::getBufferMemoryRequirementsKHR( const DeviceBufferMemoryRequirements * pInfo,
26037 MemoryRequirements2 * pMemoryRequirements,
26038 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
26039 {
26040 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26041 d.vkGetDeviceBufferMemoryRequirementsKHR( static_cast<VkDevice>( m_device ),
26042 reinterpret_cast<const VkDeviceBufferMemoryRequirements *>( pInfo ),
26043 reinterpret_cast<VkMemoryRequirements2 *>( pMemoryRequirements ) );
26044 }
26045
26046 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
26047 // wrapper function for command vkGetDeviceBufferMemoryRequirementsKHR, see
26048 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceBufferMemoryRequirementsKHR.html
26049 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26050 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 Device::getBufferMemoryRequirementsKHR( const DeviceBufferMemoryRequirements & info,
26051 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
26052 {
26053 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26054 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
26055 VULKAN_HPP_ASSERT( d.vkGetDeviceBufferMemoryRequirementsKHR &&
26056 "Function <vkGetDeviceBufferMemoryRequirementsKHR> requires <VK_KHR_maintenance4> or <VK_VERSION_1_3>" );
26057 # endif
26058
26059 MemoryRequirements2 memoryRequirements;
26060 d.vkGetDeviceBufferMemoryRequirementsKHR(
26061 m_device, reinterpret_cast<const VkDeviceBufferMemoryRequirements *>( &info ), reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
26062
26063 return memoryRequirements;
26064 }
26065
26066 // wrapper function for command vkGetDeviceBufferMemoryRequirementsKHR, see
26067 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceBufferMemoryRequirementsKHR.html
26068 template <typename X, typename Y, typename... Z, typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26069 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getBufferMemoryRequirementsKHR( const DeviceBufferMemoryRequirements & info,
26070 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
26071 {
26072 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26073 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
26074 VULKAN_HPP_ASSERT( d.vkGetDeviceBufferMemoryRequirementsKHR &&
26075 "Function <vkGetDeviceBufferMemoryRequirementsKHR> requires <VK_KHR_maintenance4> or <VK_VERSION_1_3>" );
26076 # endif
26077
26078 StructureChain<X, Y, Z...> structureChain;
26079 MemoryRequirements2 & memoryRequirements = structureChain.template get<MemoryRequirements2>();
26080 d.vkGetDeviceBufferMemoryRequirementsKHR(
26081 m_device, reinterpret_cast<const VkDeviceBufferMemoryRequirements *>( &info ), reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
26082
26083 return structureChain;
26084 }
26085 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
26086
26087 // wrapper function for command vkGetDeviceImageMemoryRequirementsKHR, see
26088 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageMemoryRequirementsKHR.html
26089 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26090 VULKAN_HPP_INLINE void Device::getImageMemoryRequirementsKHR( const DeviceImageMemoryRequirements * pInfo,
26091 MemoryRequirements2 * pMemoryRequirements,
26092 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
26093 {
26094 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26095 d.vkGetDeviceImageMemoryRequirementsKHR( static_cast<VkDevice>( m_device ),
26096 reinterpret_cast<const VkDeviceImageMemoryRequirements *>( pInfo ),
26097 reinterpret_cast<VkMemoryRequirements2 *>( pMemoryRequirements ) );
26098 }
26099
26100 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
26101 // wrapper function for command vkGetDeviceImageMemoryRequirementsKHR, see
26102 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageMemoryRequirementsKHR.html
26103 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26104 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 Device::getImageMemoryRequirementsKHR( const DeviceImageMemoryRequirements & info,
26105 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
26106 {
26107 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26108 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
26109 VULKAN_HPP_ASSERT( d.vkGetDeviceImageMemoryRequirementsKHR &&
26110 "Function <vkGetDeviceImageMemoryRequirementsKHR> requires <VK_KHR_maintenance4> or <VK_VERSION_1_3>" );
26111 # endif
26112
26113 MemoryRequirements2 memoryRequirements;
26114 d.vkGetDeviceImageMemoryRequirementsKHR(
26115 m_device, reinterpret_cast<const VkDeviceImageMemoryRequirements *>( &info ), reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
26116
26117 return memoryRequirements;
26118 }
26119
26120 // wrapper function for command vkGetDeviceImageMemoryRequirementsKHR, see
26121 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageMemoryRequirementsKHR.html
26122 template <typename X, typename Y, typename... Z, typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26123 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getImageMemoryRequirementsKHR( const DeviceImageMemoryRequirements & info,
26124 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
26125 {
26126 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26127 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
26128 VULKAN_HPP_ASSERT( d.vkGetDeviceImageMemoryRequirementsKHR &&
26129 "Function <vkGetDeviceImageMemoryRequirementsKHR> requires <VK_KHR_maintenance4> or <VK_VERSION_1_3>" );
26130 # endif
26131
26132 StructureChain<X, Y, Z...> structureChain;
26133 MemoryRequirements2 & memoryRequirements = structureChain.template get<MemoryRequirements2>();
26134 d.vkGetDeviceImageMemoryRequirementsKHR(
26135 m_device, reinterpret_cast<const VkDeviceImageMemoryRequirements *>( &info ), reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
26136
26137 return structureChain;
26138 }
26139 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
26140
26141 // wrapper function for command vkGetDeviceImageSparseMemoryRequirementsKHR, see
26142 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSparseMemoryRequirementsKHR.html
26143 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26144 VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirementsKHR( const DeviceImageMemoryRequirements * pInfo,
26145 uint32_t * pSparseMemoryRequirementCount,
26146 SparseImageMemoryRequirements2 * pSparseMemoryRequirements,
26147 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
26148 {
26149 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26150 d.vkGetDeviceImageSparseMemoryRequirementsKHR( static_cast<VkDevice>( m_device ),
26151 reinterpret_cast<const VkDeviceImageMemoryRequirements *>( pInfo ),
26152 pSparseMemoryRequirementCount,
26153 reinterpret_cast<VkSparseImageMemoryRequirements2 *>( pSparseMemoryRequirements ) );
26154 }
26155
26156 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
26157 // wrapper function for command vkGetDeviceImageSparseMemoryRequirementsKHR, see
26158 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSparseMemoryRequirementsKHR.html
26159 template <
26160 typename SparseImageMemoryRequirements2Allocator,
26161 typename Dispatch,
26162 typename std::enable_if<std::is_same<typename SparseImageMemoryRequirements2Allocator::value_type, SparseImageMemoryRequirements2>::value, int>::type,
26163 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26164 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
26165 Device::getImageSparseMemoryRequirementsKHR( const DeviceImageMemoryRequirements & info, Dispatch const & d ) const
26166 {
26167 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26168 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
26169 VULKAN_HPP_ASSERT( d.vkGetDeviceImageSparseMemoryRequirementsKHR &&
26170 "Function <vkGetDeviceImageSparseMemoryRequirementsKHR> requires <VK_KHR_maintenance4> or <VK_VERSION_1_3>" );
26171 # endif
26172
26173 std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> sparseMemoryRequirements;
26174 uint32_t sparseMemoryRequirementCount;
26175 d.vkGetDeviceImageSparseMemoryRequirementsKHR(
26176 m_device, reinterpret_cast<const VkDeviceImageMemoryRequirements *>( &info ), &sparseMemoryRequirementCount, nullptr );
26177 sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
26178 d.vkGetDeviceImageSparseMemoryRequirementsKHR( m_device,
26179 reinterpret_cast<const VkDeviceImageMemoryRequirements *>( &info ),
26180 &sparseMemoryRequirementCount,
26181 reinterpret_cast<VkSparseImageMemoryRequirements2 *>( sparseMemoryRequirements.data() ) );
26182
26183 VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() );
26184 if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() )
26185 {
26186 sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
26187 }
26188 return sparseMemoryRequirements;
26189 }
26190
26191 // wrapper function for command vkGetDeviceImageSparseMemoryRequirementsKHR, see
26192 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSparseMemoryRequirementsKHR.html
26193 template <
26194 typename SparseImageMemoryRequirements2Allocator,
26195 typename Dispatch,
26196 typename std::enable_if<std::is_same<typename SparseImageMemoryRequirements2Allocator::value_type, SparseImageMemoryRequirements2>::value, int>::type,
26197 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26198 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
26199 Device::getImageSparseMemoryRequirementsKHR( const DeviceImageMemoryRequirements & info,
26200 SparseImageMemoryRequirements2Allocator & sparseImageMemoryRequirements2Allocator,
26201 Dispatch const & d ) const
26202 {
26203 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26204 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
26205 VULKAN_HPP_ASSERT( d.vkGetDeviceImageSparseMemoryRequirementsKHR &&
26206 "Function <vkGetDeviceImageSparseMemoryRequirementsKHR> requires <VK_KHR_maintenance4> or <VK_VERSION_1_3>" );
26207 # endif
26208
26209 std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> sparseMemoryRequirements( sparseImageMemoryRequirements2Allocator );
26210 uint32_t sparseMemoryRequirementCount;
26211 d.vkGetDeviceImageSparseMemoryRequirementsKHR(
26212 m_device, reinterpret_cast<const VkDeviceImageMemoryRequirements *>( &info ), &sparseMemoryRequirementCount, nullptr );
26213 sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
26214 d.vkGetDeviceImageSparseMemoryRequirementsKHR( m_device,
26215 reinterpret_cast<const VkDeviceImageMemoryRequirements *>( &info ),
26216 &sparseMemoryRequirementCount,
26217 reinterpret_cast<VkSparseImageMemoryRequirements2 *>( sparseMemoryRequirements.data() ) );
26218
26219 VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() );
26220 if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() )
26221 {
26222 sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
26223 }
26224 return sparseMemoryRequirements;
26225 }
26226 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
26227
26228 //=== VK_VALVE_descriptor_set_host_mapping ===
26229
26230 // wrapper function for command vkGetDescriptorSetLayoutHostMappingInfoVALVE, see
26231 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutHostMappingInfoVALVE.html
26232 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26233 VULKAN_HPP_INLINE void Device::getDescriptorSetLayoutHostMappingInfoVALVE( const DescriptorSetBindingReferenceVALVE * pBindingReference,
26234 DescriptorSetLayoutHostMappingInfoVALVE * pHostMapping,
26235 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
26236 {
26237 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26238 d.vkGetDescriptorSetLayoutHostMappingInfoVALVE( static_cast<VkDevice>( m_device ),
26239 reinterpret_cast<const VkDescriptorSetBindingReferenceVALVE *>( pBindingReference ),
26240 reinterpret_cast<VkDescriptorSetLayoutHostMappingInfoVALVE *>( pHostMapping ) );
26241 }
26242
26243 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
26244 // wrapper function for command vkGetDescriptorSetLayoutHostMappingInfoVALVE, see
26245 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutHostMappingInfoVALVE.html
26246 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26247 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DescriptorSetLayoutHostMappingInfoVALVE Device::getDescriptorSetLayoutHostMappingInfoVALVE(
26248 const DescriptorSetBindingReferenceVALVE & bindingReference, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
26249 {
26250 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26251 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
26252 VULKAN_HPP_ASSERT( d.vkGetDescriptorSetLayoutHostMappingInfoVALVE &&
26253 "Function <vkGetDescriptorSetLayoutHostMappingInfoVALVE> requires <VK_VALVE_descriptor_set_host_mapping>" );
26254 # endif
26255
26256 DescriptorSetLayoutHostMappingInfoVALVE hostMapping;
26257 d.vkGetDescriptorSetLayoutHostMappingInfoVALVE( m_device,
26258 reinterpret_cast<const VkDescriptorSetBindingReferenceVALVE *>( &bindingReference ),
26259 reinterpret_cast<VkDescriptorSetLayoutHostMappingInfoVALVE *>( &hostMapping ) );
26260
26261 return hostMapping;
26262 }
26263 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
26264
26265 // wrapper function for command vkGetDescriptorSetHostMappingVALVE, see
26266 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetHostMappingVALVE.html
26267 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26268 VULKAN_HPP_INLINE void Device::getDescriptorSetHostMappingVALVE( DescriptorSet descriptorSet, void ** ppData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
26269 {
26270 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26271 d.vkGetDescriptorSetHostMappingVALVE( static_cast<VkDevice>( m_device ), static_cast<VkDescriptorSet>( descriptorSet ), ppData );
26272 }
26273
26274 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
26275 // wrapper function for command vkGetDescriptorSetHostMappingVALVE, see
26276 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetHostMappingVALVE.html
26277 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26278 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE void * Device::getDescriptorSetHostMappingVALVE( DescriptorSet descriptorSet,
26279 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
26280 {
26281 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26282 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
26283 VULKAN_HPP_ASSERT( d.vkGetDescriptorSetHostMappingVALVE &&
26284 "Function <vkGetDescriptorSetHostMappingVALVE> requires <VK_VALVE_descriptor_set_host_mapping>" );
26285 # endif
26286
26287 void * pData;
26288 d.vkGetDescriptorSetHostMappingVALVE( m_device, static_cast<VkDescriptorSet>( descriptorSet ), &pData );
26289
26290 return pData;
26291 }
26292 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
26293
26294 //=== VK_NV_copy_memory_indirect ===
26295
26296 // wrapper function for command vkCmdCopyMemoryIndirectNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryIndirectNV.html
26297 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26298 VULKAN_HPP_INLINE void
26299 CommandBuffer::copyMemoryIndirectNV( DeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
26300 {
26301 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26302 d.vkCmdCopyMemoryIndirectNV( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkDeviceAddress>( copyBufferAddress ), copyCount, stride );
26303 }
26304
26305 // wrapper function for command vkCmdCopyMemoryToImageIndirectNV, see
26306 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToImageIndirectNV.html
26307 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26308 VULKAN_HPP_INLINE void CommandBuffer::copyMemoryToImageIndirectNV( DeviceAddress copyBufferAddress,
26309 uint32_t copyCount,
26310 uint32_t stride,
26311 Image dstImage,
26312 ImageLayout dstImageLayout,
26313 const ImageSubresourceLayers * pImageSubresources,
26314 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
26315 {
26316 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26317 d.vkCmdCopyMemoryToImageIndirectNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
26318 static_cast<VkDeviceAddress>( copyBufferAddress ),
26319 copyCount,
26320 stride,
26321 static_cast<VkImage>( dstImage ),
26322 static_cast<VkImageLayout>( dstImageLayout ),
26323 reinterpret_cast<const VkImageSubresourceLayers *>( pImageSubresources ) );
26324 }
26325
26326 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
26327 // wrapper function for command vkCmdCopyMemoryToImageIndirectNV, see
26328 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToImageIndirectNV.html
26329 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26330 VULKAN_HPP_INLINE void CommandBuffer::copyMemoryToImageIndirectNV( DeviceAddress copyBufferAddress,
26331 uint32_t stride,
26332 Image dstImage,
26333 ImageLayout dstImageLayout,
26334 ArrayProxy<const ImageSubresourceLayers> const & imageSubresources,
26335 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
26336 {
26337 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26338 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
26339 VULKAN_HPP_ASSERT( d.vkCmdCopyMemoryToImageIndirectNV && "Function <vkCmdCopyMemoryToImageIndirectNV> requires <VK_NV_copy_memory_indirect>" );
26340 # endif
26341
26342 d.vkCmdCopyMemoryToImageIndirectNV( m_commandBuffer,
26343 static_cast<VkDeviceAddress>( copyBufferAddress ),
26344 imageSubresources.size(),
26345 stride,
26346 static_cast<VkImage>( dstImage ),
26347 static_cast<VkImageLayout>( dstImageLayout ),
26348 reinterpret_cast<const VkImageSubresourceLayers *>( imageSubresources.data() ) );
26349 }
26350 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
26351
26352 //=== VK_NV_memory_decompression ===
26353
26354 // wrapper function for command vkCmdDecompressMemoryNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecompressMemoryNV.html
26355 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26356 VULKAN_HPP_INLINE void CommandBuffer::decompressMemoryNV( uint32_t decompressRegionCount,
26357 const DecompressMemoryRegionNV * pDecompressMemoryRegions,
26358 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
26359 {
26360 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26361 d.vkCmdDecompressMemoryNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
26362 decompressRegionCount,
26363 reinterpret_cast<const VkDecompressMemoryRegionNV *>( pDecompressMemoryRegions ) );
26364 }
26365
26366 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
26367 // wrapper function for command vkCmdDecompressMemoryNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecompressMemoryNV.html
26368 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26369 VULKAN_HPP_INLINE void CommandBuffer::decompressMemoryNV( ArrayProxy<const DecompressMemoryRegionNV> const & decompressMemoryRegions,
26370 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
26371 {
26372 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26373 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
26374 VULKAN_HPP_ASSERT( d.vkCmdDecompressMemoryNV && "Function <vkCmdDecompressMemoryNV> requires <VK_NV_memory_decompression>" );
26375 # endif
26376
26377 d.vkCmdDecompressMemoryNV(
26378 m_commandBuffer, decompressMemoryRegions.size(), reinterpret_cast<const VkDecompressMemoryRegionNV *>( decompressMemoryRegions.data() ) );
26379 }
26380 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
26381
26382 // wrapper function for command vkCmdDecompressMemoryIndirectCountNV, see
26383 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecompressMemoryIndirectCountNV.html
26384 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26385 VULKAN_HPP_INLINE void CommandBuffer::decompressMemoryIndirectCountNV( DeviceAddress indirectCommandsAddress,
26386 DeviceAddress indirectCommandsCountAddress,
26387 uint32_t stride,
26388 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
26389 {
26390 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26391 d.vkCmdDecompressMemoryIndirectCountNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
26392 static_cast<VkDeviceAddress>( indirectCommandsAddress ),
26393 static_cast<VkDeviceAddress>( indirectCommandsCountAddress ),
26394 stride );
26395 }
26396
26397 //=== VK_NV_device_generated_commands_compute ===
26398
26399 // wrapper function for command vkGetPipelineIndirectMemoryRequirementsNV, see
26400 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineIndirectMemoryRequirementsNV.html
26401 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26402 VULKAN_HPP_INLINE void Device::getPipelineIndirectMemoryRequirementsNV( const ComputePipelineCreateInfo * pCreateInfo,
26403 MemoryRequirements2 * pMemoryRequirements,
26404 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
26405 {
26406 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26407 d.vkGetPipelineIndirectMemoryRequirementsNV( static_cast<VkDevice>( m_device ),
26408 reinterpret_cast<const VkComputePipelineCreateInfo *>( pCreateInfo ),
26409 reinterpret_cast<VkMemoryRequirements2 *>( pMemoryRequirements ) );
26410 }
26411
26412 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
26413 // wrapper function for command vkGetPipelineIndirectMemoryRequirementsNV, see
26414 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineIndirectMemoryRequirementsNV.html
26415 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26416 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 Device::getPipelineIndirectMemoryRequirementsNV( const ComputePipelineCreateInfo & createInfo,
26417 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
26418 {
26419 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26420 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
26421 VULKAN_HPP_ASSERT( d.vkGetPipelineIndirectMemoryRequirementsNV &&
26422 "Function <vkGetPipelineIndirectMemoryRequirementsNV> requires <VK_NV_device_generated_commands_compute>" );
26423 # endif
26424
26425 MemoryRequirements2 memoryRequirements;
26426 d.vkGetPipelineIndirectMemoryRequirementsNV(
26427 m_device, reinterpret_cast<const VkComputePipelineCreateInfo *>( &createInfo ), reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
26428
26429 return memoryRequirements;
26430 }
26431
26432 // wrapper function for command vkGetPipelineIndirectMemoryRequirementsNV, see
26433 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineIndirectMemoryRequirementsNV.html
26434 template <typename X, typename Y, typename... Z, typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26435 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...>
26436 Device::getPipelineIndirectMemoryRequirementsNV( const ComputePipelineCreateInfo & createInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
26437 {
26438 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26439 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
26440 VULKAN_HPP_ASSERT( d.vkGetPipelineIndirectMemoryRequirementsNV &&
26441 "Function <vkGetPipelineIndirectMemoryRequirementsNV> requires <VK_NV_device_generated_commands_compute>" );
26442 # endif
26443
26444 StructureChain<X, Y, Z...> structureChain;
26445 MemoryRequirements2 & memoryRequirements = structureChain.template get<MemoryRequirements2>();
26446 d.vkGetPipelineIndirectMemoryRequirementsNV(
26447 m_device, reinterpret_cast<const VkComputePipelineCreateInfo *>( &createInfo ), reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
26448
26449 return structureChain;
26450 }
26451 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
26452
26453 // wrapper function for command vkCmdUpdatePipelineIndirectBufferNV, see
26454 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdUpdatePipelineIndirectBufferNV.html
26455 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26456 VULKAN_HPP_INLINE void
26457 CommandBuffer::updatePipelineIndirectBufferNV( PipelineBindPoint pipelineBindPoint, Pipeline pipeline, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
26458 {
26459 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26460 d.vkCmdUpdatePipelineIndirectBufferNV(
26461 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkPipelineBindPoint>( pipelineBindPoint ), static_cast<VkPipeline>( pipeline ) );
26462 }
26463
26464 // wrapper function for command vkGetPipelineIndirectDeviceAddressNV, see
26465 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineIndirectDeviceAddressNV.html
26466 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26467 VULKAN_HPP_INLINE DeviceAddress Device::getPipelineIndirectAddressNV( const PipelineIndirectDeviceAddressInfoNV * pInfo,
26468 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
26469 {
26470 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26471 return static_cast<DeviceAddress>(
26472 d.vkGetPipelineIndirectDeviceAddressNV( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkPipelineIndirectDeviceAddressInfoNV *>( pInfo ) ) );
26473 }
26474
26475 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
26476 // wrapper function for command vkGetPipelineIndirectDeviceAddressNV, see
26477 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineIndirectDeviceAddressNV.html
26478 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26479 VULKAN_HPP_INLINE DeviceAddress Device::getPipelineIndirectAddressNV( const PipelineIndirectDeviceAddressInfoNV & info,
26480 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
26481 {
26482 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26483 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
26484 VULKAN_HPP_ASSERT( d.vkGetPipelineIndirectDeviceAddressNV &&
26485 "Function <vkGetPipelineIndirectDeviceAddressNV> requires <VK_NV_device_generated_commands_compute>" );
26486 # endif
26487
26488 VkDeviceAddress result = d.vkGetPipelineIndirectDeviceAddressNV( m_device, reinterpret_cast<const VkPipelineIndirectDeviceAddressInfoNV *>( &info ) );
26489
26490 return static_cast<DeviceAddress>( result );
26491 }
26492 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
26493
26494 #if defined( VK_USE_PLATFORM_OHOS )
26495 //=== VK_OHOS_external_memory ===
26496
26497 // wrapper function for command vkGetNativeBufferPropertiesOHOS, see
26498 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetNativeBufferPropertiesOHOS.html
26499 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26500 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getNativeBufferPropertiesOHOS( const struct OH_NativeBuffer * buffer,
26501 NativeBufferPropertiesOHOS * pProperties,
26502 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
26503 {
26504 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26505 return static_cast<Result>(
26506 d.vkGetNativeBufferPropertiesOHOS( static_cast<VkDevice>( m_device ), buffer, reinterpret_cast<VkNativeBufferPropertiesOHOS *>( pProperties ) ) );
26507 }
26508
26509 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
26510 // wrapper function for command vkGetNativeBufferPropertiesOHOS, see
26511 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetNativeBufferPropertiesOHOS.html
26512 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26513 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<NativeBufferPropertiesOHOS>::type
26514 Device::getNativeBufferPropertiesOHOS( const struct OH_NativeBuffer & buffer, Dispatch const & d ) const
26515 {
26516 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26517 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
26518 VULKAN_HPP_ASSERT( d.vkGetNativeBufferPropertiesOHOS && "Function <vkGetNativeBufferPropertiesOHOS> requires <VK_OHOS_external_memory>" );
26519 # endif
26520
26521 NativeBufferPropertiesOHOS properties;
26522 Result result =
26523 static_cast<Result>( d.vkGetNativeBufferPropertiesOHOS( m_device, &buffer, reinterpret_cast<VkNativeBufferPropertiesOHOS *>( &properties ) ) );
26524 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getNativeBufferPropertiesOHOS" );
26525
26526 return detail::createResultValueType( result, std::move( properties ) );
26527 }
26528
26529 // wrapper function for command vkGetNativeBufferPropertiesOHOS, see
26530 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetNativeBufferPropertiesOHOS.html
26531 template <typename X, typename Y, typename... Z, typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26532 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<StructureChain<X, Y, Z...>>::type
26533 Device::getNativeBufferPropertiesOHOS( const struct OH_NativeBuffer & buffer, Dispatch const & d ) const
26534 {
26535 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26536 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
26537 VULKAN_HPP_ASSERT( d.vkGetNativeBufferPropertiesOHOS && "Function <vkGetNativeBufferPropertiesOHOS> requires <VK_OHOS_external_memory>" );
26538 # endif
26539
26540 StructureChain<X, Y, Z...> structureChain;
26541 NativeBufferPropertiesOHOS & properties = structureChain.template get<NativeBufferPropertiesOHOS>();
26542 Result result =
26543 static_cast<Result>( d.vkGetNativeBufferPropertiesOHOS( m_device, &buffer, reinterpret_cast<VkNativeBufferPropertiesOHOS *>( &properties ) ) );
26544 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getNativeBufferPropertiesOHOS" );
26545
26546 return detail::createResultValueType( result, std::move( structureChain ) );
26547 }
26548 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
26549
26550 // wrapper function for command vkGetMemoryNativeBufferOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryNativeBufferOHOS.html
26551 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26552 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getMemoryNativeBufferOHOS( const MemoryGetNativeBufferInfoOHOS * pInfo,
26553 struct OH_NativeBuffer ** pBuffer,
26554 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
26555 {
26556 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26557 return static_cast<Result>(
26558 d.vkGetMemoryNativeBufferOHOS( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkMemoryGetNativeBufferInfoOHOS *>( pInfo ), pBuffer ) );
26559 }
26560
26561 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
26562 // wrapper function for command vkGetMemoryNativeBufferOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryNativeBufferOHOS.html
26563 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26564 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<struct OH_NativeBuffer *>::type
26565 Device::getMemoryNativeBufferOHOS( const MemoryGetNativeBufferInfoOHOS & info, Dispatch const & d ) const
26566 {
26567 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26568 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
26569 VULKAN_HPP_ASSERT( d.vkGetMemoryNativeBufferOHOS && "Function <vkGetMemoryNativeBufferOHOS> requires <VK_OHOS_external_memory>" );
26570 # endif
26571
26572 struct OH_NativeBuffer * buffer;
26573 Result result =
26574 static_cast<Result>( d.vkGetMemoryNativeBufferOHOS( m_device, reinterpret_cast<const VkMemoryGetNativeBufferInfoOHOS *>( &info ), &buffer ) );
26575 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryNativeBufferOHOS" );
26576
26577 return detail::createResultValueType( result, std::move( buffer ) );
26578 }
26579 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
26580 #endif /*VK_USE_PLATFORM_OHOS*/
26581
26582 //=== VK_EXT_extended_dynamic_state3 ===
26583
26584 // wrapper function for command vkCmdSetDepthClampEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthClampEnableEXT.html
26585 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26586 VULKAN_HPP_INLINE void CommandBuffer::setDepthClampEnableEXT( Bool32 depthClampEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
26587 {
26588 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26589 d.vkCmdSetDepthClampEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( depthClampEnable ) );
26590 }
26591
26592 // wrapper function for command vkCmdSetPolygonModeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPolygonModeEXT.html
26593 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26594 VULKAN_HPP_INLINE void CommandBuffer::setPolygonModeEXT( PolygonMode polygonMode, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
26595 {
26596 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26597 d.vkCmdSetPolygonModeEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkPolygonMode>( polygonMode ) );
26598 }
26599
26600 // wrapper function for command vkCmdSetRasterizationSamplesEXT, see
26601 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRasterizationSamplesEXT.html
26602 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26603 VULKAN_HPP_INLINE void CommandBuffer::setRasterizationSamplesEXT( SampleCountFlagBits rasterizationSamples, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
26604 {
26605 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26606 d.vkCmdSetRasterizationSamplesEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkSampleCountFlagBits>( rasterizationSamples ) );
26607 }
26608
26609 // wrapper function for command vkCmdSetSampleMaskEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetSampleMaskEXT.html
26610 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26611 VULKAN_HPP_INLINE void
26612 CommandBuffer::setSampleMaskEXT( SampleCountFlagBits samples, const SampleMask * pSampleMask, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
26613 {
26614 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26615 d.vkCmdSetSampleMaskEXT(
26616 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkSampleCountFlagBits>( samples ), reinterpret_cast<const VkSampleMask *>( pSampleMask ) );
26617 }
26618
26619 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
26620 // wrapper function for command vkCmdSetSampleMaskEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetSampleMaskEXT.html
26621 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26622 VULKAN_HPP_INLINE void CommandBuffer::setSampleMaskEXT( SampleCountFlagBits samples,
26623 ArrayProxy<const SampleMask> const & sampleMask,
26624 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
26625 {
26626 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26627 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
26628 VULKAN_HPP_ASSERT( d.vkCmdSetSampleMaskEXT && "Function <vkCmdSetSampleMaskEXT> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" );
26629 # endif
26630 # ifdef VULKAN_HPP_NO_EXCEPTIONS
26631 VULKAN_HPP_ASSERT( sampleMask.size() == ( static_cast<uint32_t>( samples ) + 31 ) / 32 );
26632 # else
26633 if ( sampleMask.size() != ( static_cast<uint32_t>( samples ) + 31 ) / 32 )
26634 {
26635 throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::setSampleMaskEXT: sampleMask.size() != ( static_cast<uint32_t>( samples ) + 31 ) / 32" );
26636 }
26637 # endif /*VULKAN_HPP_NO_EXCEPTIONS*/
26638
26639 d.vkCmdSetSampleMaskEXT( m_commandBuffer, static_cast<VkSampleCountFlagBits>( samples ), reinterpret_cast<const VkSampleMask *>( sampleMask.data() ) );
26640 }
26641 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
26642
26643 // wrapper function for command vkCmdSetAlphaToCoverageEnableEXT, see
26644 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetAlphaToCoverageEnableEXT.html
26645 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26646 VULKAN_HPP_INLINE void CommandBuffer::setAlphaToCoverageEnableEXT( Bool32 alphaToCoverageEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
26647 {
26648 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26649 d.vkCmdSetAlphaToCoverageEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( alphaToCoverageEnable ) );
26650 }
26651
26652 // wrapper function for command vkCmdSetAlphaToOneEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetAlphaToOneEnableEXT.html
26653 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26654 VULKAN_HPP_INLINE void CommandBuffer::setAlphaToOneEnableEXT( Bool32 alphaToOneEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
26655 {
26656 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26657 d.vkCmdSetAlphaToOneEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( alphaToOneEnable ) );
26658 }
26659
26660 // wrapper function for command vkCmdSetLogicOpEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLogicOpEnableEXT.html
26661 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26662 VULKAN_HPP_INLINE void CommandBuffer::setLogicOpEnableEXT( Bool32 logicOpEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
26663 {
26664 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26665 d.vkCmdSetLogicOpEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( logicOpEnable ) );
26666 }
26667
26668 // wrapper function for command vkCmdSetColorBlendEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorBlendEnableEXT.html
26669 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26670 VULKAN_HPP_INLINE void CommandBuffer::setColorBlendEnableEXT( uint32_t firstAttachment,
26671 uint32_t attachmentCount,
26672 const Bool32 * pColorBlendEnables,
26673 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
26674 {
26675 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26676 d.vkCmdSetColorBlendEnableEXT(
26677 static_cast<VkCommandBuffer>( m_commandBuffer ), firstAttachment, attachmentCount, reinterpret_cast<const VkBool32 *>( pColorBlendEnables ) );
26678 }
26679
26680 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
26681 // wrapper function for command vkCmdSetColorBlendEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorBlendEnableEXT.html
26682 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26683 VULKAN_HPP_INLINE void CommandBuffer::setColorBlendEnableEXT( uint32_t firstAttachment,
26684 ArrayProxy<const Bool32> const & colorBlendEnables,
26685 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
26686 {
26687 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26688 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
26689 VULKAN_HPP_ASSERT( d.vkCmdSetColorBlendEnableEXT &&
26690 "Function <vkCmdSetColorBlendEnableEXT> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" );
26691 # endif
26692
26693 d.vkCmdSetColorBlendEnableEXT( m_commandBuffer, firstAttachment, colorBlendEnables.size(), reinterpret_cast<const VkBool32 *>( colorBlendEnables.data() ) );
26694 }
26695 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
26696
26697 // wrapper function for command vkCmdSetColorBlendEquationEXT, see
26698 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorBlendEquationEXT.html
26699 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26700 VULKAN_HPP_INLINE void CommandBuffer::setColorBlendEquationEXT( uint32_t firstAttachment,
26701 uint32_t attachmentCount,
26702 const ColorBlendEquationEXT * pColorBlendEquations,
26703 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
26704 {
26705 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26706 d.vkCmdSetColorBlendEquationEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
26707 firstAttachment,
26708 attachmentCount,
26709 reinterpret_cast<const VkColorBlendEquationEXT *>( pColorBlendEquations ) );
26710 }
26711
26712 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
26713 // wrapper function for command vkCmdSetColorBlendEquationEXT, see
26714 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorBlendEquationEXT.html
26715 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26716 VULKAN_HPP_INLINE void CommandBuffer::setColorBlendEquationEXT( uint32_t firstAttachment,
26717 ArrayProxy<const ColorBlendEquationEXT> const & colorBlendEquations,
26718 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
26719 {
26720 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26721 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
26722 VULKAN_HPP_ASSERT( d.vkCmdSetColorBlendEquationEXT &&
26723 "Function <vkCmdSetColorBlendEquationEXT> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" );
26724 # endif
26725
26726 d.vkCmdSetColorBlendEquationEXT(
26727 m_commandBuffer, firstAttachment, colorBlendEquations.size(), reinterpret_cast<const VkColorBlendEquationEXT *>( colorBlendEquations.data() ) );
26728 }
26729 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
26730
26731 // wrapper function for command vkCmdSetColorWriteMaskEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorWriteMaskEXT.html
26732 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26733 VULKAN_HPP_INLINE void CommandBuffer::setColorWriteMaskEXT( uint32_t firstAttachment,
26734 uint32_t attachmentCount,
26735 const ColorComponentFlags * pColorWriteMasks,
26736 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
26737 {
26738 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26739 d.vkCmdSetColorWriteMaskEXT(
26740 static_cast<VkCommandBuffer>( m_commandBuffer ), firstAttachment, attachmentCount, reinterpret_cast<const VkColorComponentFlags *>( pColorWriteMasks ) );
26741 }
26742
26743 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
26744 // wrapper function for command vkCmdSetColorWriteMaskEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorWriteMaskEXT.html
26745 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26746 VULKAN_HPP_INLINE void CommandBuffer::setColorWriteMaskEXT( uint32_t firstAttachment,
26747 ArrayProxy<const ColorComponentFlags> const & colorWriteMasks,
26748 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
26749 {
26750 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26751 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
26752 VULKAN_HPP_ASSERT( d.vkCmdSetColorWriteMaskEXT &&
26753 "Function <vkCmdSetColorWriteMaskEXT> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" );
26754 # endif
26755
26756 d.vkCmdSetColorWriteMaskEXT(
26757 m_commandBuffer, firstAttachment, colorWriteMasks.size(), reinterpret_cast<const VkColorComponentFlags *>( colorWriteMasks.data() ) );
26758 }
26759 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
26760
26761 // wrapper function for command vkCmdSetTessellationDomainOriginEXT, see
26762 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetTessellationDomainOriginEXT.html
26763 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26764 VULKAN_HPP_INLINE void CommandBuffer::setTessellationDomainOriginEXT( TessellationDomainOrigin domainOrigin, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
26765 {
26766 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26767 d.vkCmdSetTessellationDomainOriginEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkTessellationDomainOrigin>( domainOrigin ) );
26768 }
26769
26770 // wrapper function for command vkCmdSetRasterizationStreamEXT, see
26771 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRasterizationStreamEXT.html
26772 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26773 VULKAN_HPP_INLINE void CommandBuffer::setRasterizationStreamEXT( uint32_t rasterizationStream, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
26774 {
26775 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26776 d.vkCmdSetRasterizationStreamEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), rasterizationStream );
26777 }
26778
26779 // wrapper function for command vkCmdSetConservativeRasterizationModeEXT, see
26780 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetConservativeRasterizationModeEXT.html
26781 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26782 VULKAN_HPP_INLINE void CommandBuffer::setConservativeRasterizationModeEXT( ConservativeRasterizationModeEXT conservativeRasterizationMode,
26783 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
26784 {
26785 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26786 d.vkCmdSetConservativeRasterizationModeEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
26787 static_cast<VkConservativeRasterizationModeEXT>( conservativeRasterizationMode ) );
26788 }
26789
26790 // wrapper function for command vkCmdSetExtraPrimitiveOverestimationSizeEXT, see
26791 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetExtraPrimitiveOverestimationSizeEXT.html
26792 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26793 VULKAN_HPP_INLINE void CommandBuffer::setExtraPrimitiveOverestimationSizeEXT( float extraPrimitiveOverestimationSize,
26794 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
26795 {
26796 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26797 d.vkCmdSetExtraPrimitiveOverestimationSizeEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), extraPrimitiveOverestimationSize );
26798 }
26799
26800 // wrapper function for command vkCmdSetDepthClipEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthClipEnableEXT.html
26801 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26802 VULKAN_HPP_INLINE void CommandBuffer::setDepthClipEnableEXT( Bool32 depthClipEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
26803 {
26804 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26805 d.vkCmdSetDepthClipEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( depthClipEnable ) );
26806 }
26807
26808 // wrapper function for command vkCmdSetSampleLocationsEnableEXT, see
26809 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetSampleLocationsEnableEXT.html
26810 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26811 VULKAN_HPP_INLINE void CommandBuffer::setSampleLocationsEnableEXT( Bool32 sampleLocationsEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
26812 {
26813 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26814 d.vkCmdSetSampleLocationsEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( sampleLocationsEnable ) );
26815 }
26816
26817 // wrapper function for command vkCmdSetColorBlendAdvancedEXT, see
26818 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorBlendAdvancedEXT.html
26819 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26820 VULKAN_HPP_INLINE void CommandBuffer::setColorBlendAdvancedEXT( uint32_t firstAttachment,
26821 uint32_t attachmentCount,
26822 const ColorBlendAdvancedEXT * pColorBlendAdvanced,
26823 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
26824 {
26825 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26826 d.vkCmdSetColorBlendAdvancedEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
26827 firstAttachment,
26828 attachmentCount,
26829 reinterpret_cast<const VkColorBlendAdvancedEXT *>( pColorBlendAdvanced ) );
26830 }
26831
26832 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
26833 // wrapper function for command vkCmdSetColorBlendAdvancedEXT, see
26834 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorBlendAdvancedEXT.html
26835 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26836 VULKAN_HPP_INLINE void CommandBuffer::setColorBlendAdvancedEXT( uint32_t firstAttachment,
26837 ArrayProxy<const ColorBlendAdvancedEXT> const & colorBlendAdvanced,
26838 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
26839 {
26840 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26841 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
26842 VULKAN_HPP_ASSERT( d.vkCmdSetColorBlendAdvancedEXT &&
26843 "Function <vkCmdSetColorBlendAdvancedEXT> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" );
26844 # endif
26845
26846 d.vkCmdSetColorBlendAdvancedEXT(
26847 m_commandBuffer, firstAttachment, colorBlendAdvanced.size(), reinterpret_cast<const VkColorBlendAdvancedEXT *>( colorBlendAdvanced.data() ) );
26848 }
26849 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
26850
26851 // wrapper function for command vkCmdSetProvokingVertexModeEXT, see
26852 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetProvokingVertexModeEXT.html
26853 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26854 VULKAN_HPP_INLINE void CommandBuffer::setProvokingVertexModeEXT( ProvokingVertexModeEXT provokingVertexMode, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
26855 {
26856 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26857 d.vkCmdSetProvokingVertexModeEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkProvokingVertexModeEXT>( provokingVertexMode ) );
26858 }
26859
26860 // wrapper function for command vkCmdSetLineRasterizationModeEXT, see
26861 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineRasterizationModeEXT.html
26862 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26863 VULKAN_HPP_INLINE void CommandBuffer::setLineRasterizationModeEXT( LineRasterizationModeEXT lineRasterizationMode,
26864 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
26865 {
26866 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26867 d.vkCmdSetLineRasterizationModeEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkLineRasterizationModeEXT>( lineRasterizationMode ) );
26868 }
26869
26870 // wrapper function for command vkCmdSetLineStippleEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineStippleEnableEXT.html
26871 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26872 VULKAN_HPP_INLINE void CommandBuffer::setLineStippleEnableEXT( Bool32 stippledLineEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
26873 {
26874 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26875 d.vkCmdSetLineStippleEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( stippledLineEnable ) );
26876 }
26877
26878 // wrapper function for command vkCmdSetDepthClipNegativeOneToOneEXT, see
26879 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthClipNegativeOneToOneEXT.html
26880 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26881 VULKAN_HPP_INLINE void CommandBuffer::setDepthClipNegativeOneToOneEXT( Bool32 negativeOneToOne, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
26882 {
26883 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26884 d.vkCmdSetDepthClipNegativeOneToOneEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( negativeOneToOne ) );
26885 }
26886
26887 // wrapper function for command vkCmdSetViewportWScalingEnableNV, see
26888 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWScalingEnableNV.html
26889 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26890 VULKAN_HPP_INLINE void CommandBuffer::setViewportWScalingEnableNV( Bool32 viewportWScalingEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
26891 {
26892 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26893 d.vkCmdSetViewportWScalingEnableNV( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( viewportWScalingEnable ) );
26894 }
26895
26896 // wrapper function for command vkCmdSetViewportSwizzleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportSwizzleNV.html
26897 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26898 VULKAN_HPP_INLINE void CommandBuffer::setViewportSwizzleNV( uint32_t firstViewport,
26899 uint32_t viewportCount,
26900 const ViewportSwizzleNV * pViewportSwizzles,
26901 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
26902 {
26903 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26904 d.vkCmdSetViewportSwizzleNV(
26905 static_cast<VkCommandBuffer>( m_commandBuffer ), firstViewport, viewportCount, reinterpret_cast<const VkViewportSwizzleNV *>( pViewportSwizzles ) );
26906 }
26907
26908 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
26909 // wrapper function for command vkCmdSetViewportSwizzleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportSwizzleNV.html
26910 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26911 VULKAN_HPP_INLINE void CommandBuffer::setViewportSwizzleNV( uint32_t firstViewport,
26912 ArrayProxy<const ViewportSwizzleNV> const & viewportSwizzles,
26913 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
26914 {
26915 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26916 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
26917 VULKAN_HPP_ASSERT( d.vkCmdSetViewportSwizzleNV &&
26918 "Function <vkCmdSetViewportSwizzleNV> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" );
26919 # endif
26920
26921 d.vkCmdSetViewportSwizzleNV(
26922 m_commandBuffer, firstViewport, viewportSwizzles.size(), reinterpret_cast<const VkViewportSwizzleNV *>( viewportSwizzles.data() ) );
26923 }
26924 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
26925
26926 // wrapper function for command vkCmdSetCoverageToColorEnableNV, see
26927 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageToColorEnableNV.html
26928 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26929 VULKAN_HPP_INLINE void CommandBuffer::setCoverageToColorEnableNV( Bool32 coverageToColorEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
26930 {
26931 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26932 d.vkCmdSetCoverageToColorEnableNV( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( coverageToColorEnable ) );
26933 }
26934
26935 // wrapper function for command vkCmdSetCoverageToColorLocationNV, see
26936 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageToColorLocationNV.html
26937 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26938 VULKAN_HPP_INLINE void CommandBuffer::setCoverageToColorLocationNV( uint32_t coverageToColorLocation, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
26939 {
26940 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26941 d.vkCmdSetCoverageToColorLocationNV( static_cast<VkCommandBuffer>( m_commandBuffer ), coverageToColorLocation );
26942 }
26943
26944 // wrapper function for command vkCmdSetCoverageModulationModeNV, see
26945 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageModulationModeNV.html
26946 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26947 VULKAN_HPP_INLINE void CommandBuffer::setCoverageModulationModeNV( CoverageModulationModeNV coverageModulationMode,
26948 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
26949 {
26950 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26951 d.vkCmdSetCoverageModulationModeNV( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkCoverageModulationModeNV>( coverageModulationMode ) );
26952 }
26953
26954 // wrapper function for command vkCmdSetCoverageModulationTableEnableNV, see
26955 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageModulationTableEnableNV.html
26956 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26957 VULKAN_HPP_INLINE void CommandBuffer::setCoverageModulationTableEnableNV( Bool32 coverageModulationTableEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
26958 {
26959 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26960 d.vkCmdSetCoverageModulationTableEnableNV( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( coverageModulationTableEnable ) );
26961 }
26962
26963 // wrapper function for command vkCmdSetCoverageModulationTableNV, see
26964 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageModulationTableNV.html
26965 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26966 VULKAN_HPP_INLINE void CommandBuffer::setCoverageModulationTableNV( uint32_t coverageModulationTableCount,
26967 const float * pCoverageModulationTable,
26968 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
26969 {
26970 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26971 d.vkCmdSetCoverageModulationTableNV( static_cast<VkCommandBuffer>( m_commandBuffer ), coverageModulationTableCount, pCoverageModulationTable );
26972 }
26973
26974 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
26975 // wrapper function for command vkCmdSetCoverageModulationTableNV, see
26976 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageModulationTableNV.html
26977 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26978 VULKAN_HPP_INLINE void CommandBuffer::setCoverageModulationTableNV( ArrayProxy<const float> const & coverageModulationTable,
26979 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
26980 {
26981 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26982 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
26983 VULKAN_HPP_ASSERT( d.vkCmdSetCoverageModulationTableNV &&
26984 "Function <vkCmdSetCoverageModulationTableNV> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" );
26985 # endif
26986
26987 d.vkCmdSetCoverageModulationTableNV( m_commandBuffer, coverageModulationTable.size(), coverageModulationTable.data() );
26988 }
26989 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
26990
26991 // wrapper function for command vkCmdSetShadingRateImageEnableNV, see
26992 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetShadingRateImageEnableNV.html
26993 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
26994 VULKAN_HPP_INLINE void CommandBuffer::setShadingRateImageEnableNV( Bool32 shadingRateImageEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
26995 {
26996 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
26997 d.vkCmdSetShadingRateImageEnableNV( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( shadingRateImageEnable ) );
26998 }
26999
27000 // wrapper function for command vkCmdSetRepresentativeFragmentTestEnableNV, see
27001 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRepresentativeFragmentTestEnableNV.html
27002 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
27003 VULKAN_HPP_INLINE void CommandBuffer::setRepresentativeFragmentTestEnableNV( Bool32 representativeFragmentTestEnable,
27004 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
27005 {
27006 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
27007 d.vkCmdSetRepresentativeFragmentTestEnableNV( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( representativeFragmentTestEnable ) );
27008 }
27009
27010 // wrapper function for command vkCmdSetCoverageReductionModeNV, see
27011 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageReductionModeNV.html
27012 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
27013 VULKAN_HPP_INLINE void CommandBuffer::setCoverageReductionModeNV( CoverageReductionModeNV coverageReductionMode,
27014 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
27015 {
27016 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
27017 d.vkCmdSetCoverageReductionModeNV( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkCoverageReductionModeNV>( coverageReductionMode ) );
27018 }
27019
27020 //=== VK_ARM_tensors ===
27021
27022 // wrapper function for command vkCreateTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateTensorARM.html
27023 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
27024 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createTensorARM( const TensorCreateInfoARM * pCreateInfo,
27025 const AllocationCallbacks * pAllocator,
27026 TensorARM * pTensor,
27027 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
27028 {
27029 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
27030 return static_cast<Result>( d.vkCreateTensorARM( static_cast<VkDevice>( m_device ),
27031 reinterpret_cast<const VkTensorCreateInfoARM *>( pCreateInfo ),
27032 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
27033 reinterpret_cast<VkTensorARM *>( pTensor ) ) );
27034 }
27035
27036 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
27037 // wrapper function for command vkCreateTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateTensorARM.html
27038 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
27039 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<TensorARM>::type
27040 Device::createTensorARM( const TensorCreateInfoARM & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
27041 {
27042 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
27043 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
27044 VULKAN_HPP_ASSERT( d.vkCreateTensorARM && "Function <vkCreateTensorARM> requires <VK_ARM_tensors>" );
27045 # endif
27046
27047 TensorARM tensor;
27048 Result result = static_cast<Result>( d.vkCreateTensorARM( m_device,
27049 reinterpret_cast<const VkTensorCreateInfoARM *>( &createInfo ),
27050 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
27051 reinterpret_cast<VkTensorARM *>( &tensor ) ) );
27052 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createTensorARM" );
27053
27054 return detail::createResultValueType( result, std::move( tensor ) );
27055 }
27056
27057 # ifndef VULKAN_HPP_NO_SMART_HANDLE
27058 // wrapper function for command vkCreateTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateTensorARM.html
27059 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
27060 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<TensorARM, Dispatch>>::type
27061 Device::createTensorARMUnique( const TensorCreateInfoARM & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
27062 {
27063 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
27064 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
27065 VULKAN_HPP_ASSERT( d.vkCreateTensorARM && "Function <vkCreateTensorARM> requires <VK_ARM_tensors>" );
27066 # endif
27067
27068 TensorARM tensor;
27069 Result result = static_cast<Result>( d.vkCreateTensorARM( m_device,
27070 reinterpret_cast<const VkTensorCreateInfoARM *>( &createInfo ),
27071 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
27072 reinterpret_cast<VkTensorARM *>( &tensor ) ) );
27073 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createTensorARMUnique" );
27074
27075 return detail::createResultValueType( result, UniqueHandle<TensorARM, Dispatch>( tensor, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
27076 }
27077 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
27078 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
27079
27080 // wrapper function for command vkDestroyTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyTensorARM.html
27081 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
27082 VULKAN_HPP_INLINE void Device::destroyTensorARM( TensorARM tensor, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
27083 {
27084 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
27085 d.vkDestroyTensorARM(
27086 static_cast<VkDevice>( m_device ), static_cast<VkTensorARM>( tensor ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
27087 }
27088
27089 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
27090 // wrapper function for command vkDestroyTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyTensorARM.html
27091 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
27092 VULKAN_HPP_INLINE void
27093 Device::destroyTensorARM( TensorARM tensor, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
27094 {
27095 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
27096 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
27097 VULKAN_HPP_ASSERT( d.vkDestroyTensorARM && "Function <vkDestroyTensorARM> requires <VK_ARM_tensors>" );
27098 # endif
27099
27100 d.vkDestroyTensorARM( m_device, static_cast<VkTensorARM>( tensor ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
27101 }
27102 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
27103
27104 // wrapper function for command vkDestroyTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyTensorARM.html
27105 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
27106 VULKAN_HPP_INLINE void Device::destroy( TensorARM tensor, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
27107 {
27108 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
27109 d.vkDestroyTensorARM(
27110 static_cast<VkDevice>( m_device ), static_cast<VkTensorARM>( tensor ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
27111 }
27112
27113 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
27114 // wrapper function for command vkDestroyTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyTensorARM.html
27115 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
27116 VULKAN_HPP_INLINE void Device::destroy( TensorARM tensor, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
27117 {
27118 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
27119 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
27120 VULKAN_HPP_ASSERT( d.vkDestroyTensorARM && "Function <vkDestroyTensorARM> requires <VK_ARM_tensors>" );
27121 # endif
27122
27123 d.vkDestroyTensorARM( m_device, static_cast<VkTensorARM>( tensor ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
27124 }
27125 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
27126
27127 // wrapper function for command vkCreateTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateTensorViewARM.html
27128 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
27129 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createTensorViewARM( const TensorViewCreateInfoARM * pCreateInfo,
27130 const AllocationCallbacks * pAllocator,
27131 TensorViewARM * pView,
27132 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
27133 {
27134 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
27135 return static_cast<Result>( d.vkCreateTensorViewARM( static_cast<VkDevice>( m_device ),
27136 reinterpret_cast<const VkTensorViewCreateInfoARM *>( pCreateInfo ),
27137 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
27138 reinterpret_cast<VkTensorViewARM *>( pView ) ) );
27139 }
27140
27141 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
27142 // wrapper function for command vkCreateTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateTensorViewARM.html
27143 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
27144 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<TensorViewARM>::type
27145 Device::createTensorViewARM( const TensorViewCreateInfoARM & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
27146 {
27147 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
27148 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
27149 VULKAN_HPP_ASSERT( d.vkCreateTensorViewARM && "Function <vkCreateTensorViewARM> requires <VK_ARM_tensors>" );
27150 # endif
27151
27152 TensorViewARM view;
27153 Result result = static_cast<Result>( d.vkCreateTensorViewARM( m_device,
27154 reinterpret_cast<const VkTensorViewCreateInfoARM *>( &createInfo ),
27155 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
27156 reinterpret_cast<VkTensorViewARM *>( &view ) ) );
27157 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createTensorViewARM" );
27158
27159 return detail::createResultValueType( result, std::move( view ) );
27160 }
27161
27162 # ifndef VULKAN_HPP_NO_SMART_HANDLE
27163 // wrapper function for command vkCreateTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateTensorViewARM.html
27164 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
27165 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<TensorViewARM, Dispatch>>::type
27166 Device::createTensorViewARMUnique( const TensorViewCreateInfoARM & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
27167 {
27168 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
27169 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
27170 VULKAN_HPP_ASSERT( d.vkCreateTensorViewARM && "Function <vkCreateTensorViewARM> requires <VK_ARM_tensors>" );
27171 # endif
27172
27173 TensorViewARM view;
27174 Result result = static_cast<Result>( d.vkCreateTensorViewARM( m_device,
27175 reinterpret_cast<const VkTensorViewCreateInfoARM *>( &createInfo ),
27176 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
27177 reinterpret_cast<VkTensorViewARM *>( &view ) ) );
27178 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createTensorViewARMUnique" );
27179
27180 return detail::createResultValueType( result,
27181 UniqueHandle<TensorViewARM, Dispatch>( view, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
27182 }
27183 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
27184 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
27185
27186 // wrapper function for command vkDestroyTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyTensorViewARM.html
27187 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
27188 VULKAN_HPP_INLINE void
27189 Device::destroyTensorViewARM( TensorViewARM tensorView, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
27190 {
27191 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
27192 d.vkDestroyTensorViewARM(
27193 static_cast<VkDevice>( m_device ), static_cast<VkTensorViewARM>( tensorView ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
27194 }
27195
27196 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
27197 // wrapper function for command vkDestroyTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyTensorViewARM.html
27198 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
27199 VULKAN_HPP_INLINE void
27200 Device::destroyTensorViewARM( TensorViewARM tensorView, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
27201 {
27202 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
27203 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
27204 VULKAN_HPP_ASSERT( d.vkDestroyTensorViewARM && "Function <vkDestroyTensorViewARM> requires <VK_ARM_tensors>" );
27205 # endif
27206
27207 d.vkDestroyTensorViewARM( m_device, static_cast<VkTensorViewARM>( tensorView ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
27208 }
27209 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
27210
27211 // wrapper function for command vkDestroyTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyTensorViewARM.html
27212 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
27213 VULKAN_HPP_INLINE void Device::destroy( TensorViewARM tensorView, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
27214 {
27215 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
27216 d.vkDestroyTensorViewARM(
27217 static_cast<VkDevice>( m_device ), static_cast<VkTensorViewARM>( tensorView ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
27218 }
27219
27220 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
27221 // wrapper function for command vkDestroyTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyTensorViewARM.html
27222 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
27223 VULKAN_HPP_INLINE void
27224 Device::destroy( TensorViewARM tensorView, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
27225 {
27226 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
27227 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
27228 VULKAN_HPP_ASSERT( d.vkDestroyTensorViewARM && "Function <vkDestroyTensorViewARM> requires <VK_ARM_tensors>" );
27229 # endif
27230
27231 d.vkDestroyTensorViewARM( m_device, static_cast<VkTensorViewARM>( tensorView ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
27232 }
27233 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
27234
27235 // wrapper function for command vkGetTensorMemoryRequirementsARM, see
27236 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorMemoryRequirementsARM.html
27237 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
27238 VULKAN_HPP_INLINE void Device::getTensorMemoryRequirementsARM( const TensorMemoryRequirementsInfoARM * pInfo,
27239 MemoryRequirements2 * pMemoryRequirements,
27240 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
27241 {
27242 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
27243 d.vkGetTensorMemoryRequirementsARM( static_cast<VkDevice>( m_device ),
27244 reinterpret_cast<const VkTensorMemoryRequirementsInfoARM *>( pInfo ),
27245 reinterpret_cast<VkMemoryRequirements2 *>( pMemoryRequirements ) );
27246 }
27247
27248 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
27249 // wrapper function for command vkGetTensorMemoryRequirementsARM, see
27250 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorMemoryRequirementsARM.html
27251 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
27252 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 Device::getTensorMemoryRequirementsARM( const TensorMemoryRequirementsInfoARM & info,
27253 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
27254 {
27255 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
27256 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
27257 VULKAN_HPP_ASSERT( d.vkGetTensorMemoryRequirementsARM && "Function <vkGetTensorMemoryRequirementsARM> requires <VK_ARM_tensors>" );
27258 # endif
27259
27260 MemoryRequirements2 memoryRequirements;
27261 d.vkGetTensorMemoryRequirementsARM(
27262 m_device, reinterpret_cast<const VkTensorMemoryRequirementsInfoARM *>( &info ), reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
27263
27264 return memoryRequirements;
27265 }
27266
27267 // wrapper function for command vkGetTensorMemoryRequirementsARM, see
27268 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorMemoryRequirementsARM.html
27269 template <typename X, typename Y, typename... Z, typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
27270 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getTensorMemoryRequirementsARM( const TensorMemoryRequirementsInfoARM & info,
27271 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
27272 {
27273 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
27274 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
27275 VULKAN_HPP_ASSERT( d.vkGetTensorMemoryRequirementsARM && "Function <vkGetTensorMemoryRequirementsARM> requires <VK_ARM_tensors>" );
27276 # endif
27277
27278 StructureChain<X, Y, Z...> structureChain;
27279 MemoryRequirements2 & memoryRequirements = structureChain.template get<MemoryRequirements2>();
27280 d.vkGetTensorMemoryRequirementsARM(
27281 m_device, reinterpret_cast<const VkTensorMemoryRequirementsInfoARM *>( &info ), reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
27282
27283 return structureChain;
27284 }
27285 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
27286
27287 // wrapper function for command vkBindTensorMemoryARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindTensorMemoryARM.html
27288 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
27289 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::bindTensorMemoryARM( uint32_t bindInfoCount,
27290 const BindTensorMemoryInfoARM * pBindInfos,
27291 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
27292 {
27293 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
27294 return static_cast<Result>(
27295 d.vkBindTensorMemoryARM( static_cast<VkDevice>( m_device ), bindInfoCount, reinterpret_cast<const VkBindTensorMemoryInfoARM *>( pBindInfos ) ) );
27296 }
27297
27298 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
27299 // wrapper function for command vkBindTensorMemoryARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindTensorMemoryARM.html
27300 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
27301 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
27302 Device::bindTensorMemoryARM( ArrayProxy<const BindTensorMemoryInfoARM> const & bindInfos, Dispatch const & d ) const
27303 {
27304 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
27305 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
27306 VULKAN_HPP_ASSERT( d.vkBindTensorMemoryARM && "Function <vkBindTensorMemoryARM> requires <VK_ARM_tensors>" );
27307 # endif
27308
27309 Result result =
27310 static_cast<Result>( d.vkBindTensorMemoryARM( m_device, bindInfos.size(), reinterpret_cast<const VkBindTensorMemoryInfoARM *>( bindInfos.data() ) ) );
27311 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindTensorMemoryARM" );
27312
27313 return detail::createResultValueType( result );
27314 }
27315 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
27316
27317 // wrapper function for command vkGetDeviceTensorMemoryRequirementsARM, see
27318 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceTensorMemoryRequirementsARM.html
27319 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
27320 VULKAN_HPP_INLINE void Device::getTensorMemoryRequirementsARM( const DeviceTensorMemoryRequirementsARM * pInfo,
27321 MemoryRequirements2 * pMemoryRequirements,
27322 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
27323 {
27324 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
27325 d.vkGetDeviceTensorMemoryRequirementsARM( static_cast<VkDevice>( m_device ),
27326 reinterpret_cast<const VkDeviceTensorMemoryRequirementsARM *>( pInfo ),
27327 reinterpret_cast<VkMemoryRequirements2 *>( pMemoryRequirements ) );
27328 }
27329
27330 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
27331 // wrapper function for command vkGetDeviceTensorMemoryRequirementsARM, see
27332 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceTensorMemoryRequirementsARM.html
27333 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
27334 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 Device::getTensorMemoryRequirementsARM( const DeviceTensorMemoryRequirementsARM & info,
27335 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
27336 {
27337 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
27338 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
27339 VULKAN_HPP_ASSERT( d.vkGetDeviceTensorMemoryRequirementsARM && "Function <vkGetDeviceTensorMemoryRequirementsARM> requires <VK_ARM_tensors>" );
27340 # endif
27341
27342 MemoryRequirements2 memoryRequirements;
27343 d.vkGetDeviceTensorMemoryRequirementsARM(
27344 m_device, reinterpret_cast<const VkDeviceTensorMemoryRequirementsARM *>( &info ), reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
27345
27346 return memoryRequirements;
27347 }
27348
27349 // wrapper function for command vkGetDeviceTensorMemoryRequirementsARM, see
27350 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceTensorMemoryRequirementsARM.html
27351 template <typename X, typename Y, typename... Z, typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
27352 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getTensorMemoryRequirementsARM( const DeviceTensorMemoryRequirementsARM & info,
27353 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
27354 {
27355 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
27356 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
27357 VULKAN_HPP_ASSERT( d.vkGetDeviceTensorMemoryRequirementsARM && "Function <vkGetDeviceTensorMemoryRequirementsARM> requires <VK_ARM_tensors>" );
27358 # endif
27359
27360 StructureChain<X, Y, Z...> structureChain;
27361 MemoryRequirements2 & memoryRequirements = structureChain.template get<MemoryRequirements2>();
27362 d.vkGetDeviceTensorMemoryRequirementsARM(
27363 m_device, reinterpret_cast<const VkDeviceTensorMemoryRequirementsARM *>( &info ), reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
27364
27365 return structureChain;
27366 }
27367 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
27368
27369 // wrapper function for command vkCmdCopyTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyTensorARM.html
27370 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
27371 VULKAN_HPP_INLINE void CommandBuffer::copyTensorARM( const CopyTensorInfoARM * pCopyTensorInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
27372 {
27373 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
27374 d.vkCmdCopyTensorARM( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkCopyTensorInfoARM *>( pCopyTensorInfo ) );
27375 }
27376
27377 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
27378 // wrapper function for command vkCmdCopyTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyTensorARM.html
27379 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
27380 VULKAN_HPP_INLINE void CommandBuffer::copyTensorARM( const CopyTensorInfoARM & copyTensorInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
27381 {
27382 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
27383 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
27384 VULKAN_HPP_ASSERT( d.vkCmdCopyTensorARM && "Function <vkCmdCopyTensorARM> requires <VK_ARM_tensors>" );
27385 # endif
27386
27387 d.vkCmdCopyTensorARM( m_commandBuffer, reinterpret_cast<const VkCopyTensorInfoARM *>( &copyTensorInfo ) );
27388 }
27389 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
27390
27391 // wrapper function for command vkGetPhysicalDeviceExternalTensorPropertiesARM, see
27392 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalTensorPropertiesARM.html
27393 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
27394 VULKAN_HPP_INLINE void PhysicalDevice::getExternalTensorPropertiesARM( const PhysicalDeviceExternalTensorInfoARM * pExternalTensorInfo,
27395 ExternalTensorPropertiesARM * pExternalTensorProperties,
27396 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
27397 {
27398 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
27399 d.vkGetPhysicalDeviceExternalTensorPropertiesARM( static_cast<VkPhysicalDevice>( m_physicalDevice ),
27400 reinterpret_cast<const VkPhysicalDeviceExternalTensorInfoARM *>( pExternalTensorInfo ),
27401 reinterpret_cast<VkExternalTensorPropertiesARM *>( pExternalTensorProperties ) );
27402 }
27403
27404 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
27405 // wrapper function for command vkGetPhysicalDeviceExternalTensorPropertiesARM, see
27406 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalTensorPropertiesARM.html
27407 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
27408 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ExternalTensorPropertiesARM PhysicalDevice::getExternalTensorPropertiesARM(
27409 const PhysicalDeviceExternalTensorInfoARM & externalTensorInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
27410 {
27411 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
27412 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
27413 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceExternalTensorPropertiesARM &&
27414 "Function <vkGetPhysicalDeviceExternalTensorPropertiesARM> requires <VK_ARM_tensors>" );
27415 # endif
27416
27417 ExternalTensorPropertiesARM externalTensorProperties;
27418 d.vkGetPhysicalDeviceExternalTensorPropertiesARM( m_physicalDevice,
27419 reinterpret_cast<const VkPhysicalDeviceExternalTensorInfoARM *>( &externalTensorInfo ),
27420 reinterpret_cast<VkExternalTensorPropertiesARM *>( &externalTensorProperties ) );
27421
27422 return externalTensorProperties;
27423 }
27424 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
27425
27426 // wrapper function for command vkGetTensorOpaqueCaptureDescriptorDataARM, see
27427 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorOpaqueCaptureDescriptorDataARM.html
27428 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
27429 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getTensorOpaqueCaptureDescriptorDataARM( const TensorCaptureDescriptorDataInfoARM * pInfo,
27430 void * pData,
27431 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
27432 {
27433 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
27434 return static_cast<Result>( d.vkGetTensorOpaqueCaptureDescriptorDataARM(
27435 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkTensorCaptureDescriptorDataInfoARM *>( pInfo ), pData ) );
27436 }
27437
27438 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
27439 // wrapper function for command vkGetTensorOpaqueCaptureDescriptorDataARM, see
27440 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorOpaqueCaptureDescriptorDataARM.html
27441 template <typename DataType, typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
27442 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<DataType>::type
27443 Device::getTensorOpaqueCaptureDescriptorDataARM( const TensorCaptureDescriptorDataInfoARM & info, Dispatch const & d ) const
27444 {
27445 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
27446 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
27447 VULKAN_HPP_ASSERT( d.vkGetTensorOpaqueCaptureDescriptorDataARM && "Function <vkGetTensorOpaqueCaptureDescriptorDataARM> requires <VK_ARM_tensors>" );
27448 # endif
27449
27450 DataType data;
27451 Result result = static_cast<Result>(
27452 d.vkGetTensorOpaqueCaptureDescriptorDataARM( m_device, reinterpret_cast<const VkTensorCaptureDescriptorDataInfoARM *>( &info ), &data ) );
27453 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getTensorOpaqueCaptureDescriptorDataARM" );
27454
27455 return detail::createResultValueType( result, std::move( data ) );
27456 }
27457 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
27458
27459 // wrapper function for command vkGetTensorViewOpaqueCaptureDescriptorDataARM, see
27460 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorViewOpaqueCaptureDescriptorDataARM.html
27461 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
27462 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getTensorViewOpaqueCaptureDescriptorDataARM( const TensorViewCaptureDescriptorDataInfoARM * pInfo,
27463 void * pData,
27464 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
27465 {
27466 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
27467 return static_cast<Result>( d.vkGetTensorViewOpaqueCaptureDescriptorDataARM(
27468 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkTensorViewCaptureDescriptorDataInfoARM *>( pInfo ), pData ) );
27469 }
27470
27471 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
27472 // wrapper function for command vkGetTensorViewOpaqueCaptureDescriptorDataARM, see
27473 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorViewOpaqueCaptureDescriptorDataARM.html
27474 template <typename DataType, typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
27475 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<DataType>::type
27476 Device::getTensorViewOpaqueCaptureDescriptorDataARM( const TensorViewCaptureDescriptorDataInfoARM & info, Dispatch const & d ) const
27477 {
27478 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
27479 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
27480 VULKAN_HPP_ASSERT( d.vkGetTensorViewOpaqueCaptureDescriptorDataARM &&
27481 "Function <vkGetTensorViewOpaqueCaptureDescriptorDataARM> requires <VK_ARM_tensors>" );
27482 # endif
27483
27484 DataType data;
27485 Result result = static_cast<Result>(
27486 d.vkGetTensorViewOpaqueCaptureDescriptorDataARM( m_device, reinterpret_cast<const VkTensorViewCaptureDescriptorDataInfoARM *>( &info ), &data ) );
27487 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getTensorViewOpaqueCaptureDescriptorDataARM" );
27488
27489 return detail::createResultValueType( result, std::move( data ) );
27490 }
27491 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
27492
27493 //=== VK_EXT_shader_module_identifier ===
27494
27495 // wrapper function for command vkGetShaderModuleIdentifierEXT, see
27496 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderModuleIdentifierEXT.html
27497 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
27498 VULKAN_HPP_INLINE void
27499 Device::getShaderModuleIdentifierEXT( ShaderModule shaderModule, ShaderModuleIdentifierEXT * pIdentifier, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
27500 {
27501 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
27502 d.vkGetShaderModuleIdentifierEXT(
27503 static_cast<VkDevice>( m_device ), static_cast<VkShaderModule>( shaderModule ), reinterpret_cast<VkShaderModuleIdentifierEXT *>( pIdentifier ) );
27504 }
27505
27506 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
27507 // wrapper function for command vkGetShaderModuleIdentifierEXT, see
27508 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderModuleIdentifierEXT.html
27509 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
27510 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ShaderModuleIdentifierEXT Device::getShaderModuleIdentifierEXT( ShaderModule shaderModule,
27511 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
27512 {
27513 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
27514 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
27515 VULKAN_HPP_ASSERT( d.vkGetShaderModuleIdentifierEXT && "Function <vkGetShaderModuleIdentifierEXT> requires <VK_EXT_shader_module_identifier>" );
27516 # endif
27517
27518 ShaderModuleIdentifierEXT identifier;
27519 d.vkGetShaderModuleIdentifierEXT( m_device, static_cast<VkShaderModule>( shaderModule ), reinterpret_cast<VkShaderModuleIdentifierEXT *>( &identifier ) );
27520
27521 return identifier;
27522 }
27523 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
27524
27525 // wrapper function for command vkGetShaderModuleCreateInfoIdentifierEXT, see
27526 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderModuleCreateInfoIdentifierEXT.html
27527 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
27528 VULKAN_HPP_INLINE void Device::getShaderModuleCreateInfoIdentifierEXT( const ShaderModuleCreateInfo * pCreateInfo,
27529 ShaderModuleIdentifierEXT * pIdentifier,
27530 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
27531 {
27532 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
27533 d.vkGetShaderModuleCreateInfoIdentifierEXT( static_cast<VkDevice>( m_device ),
27534 reinterpret_cast<const VkShaderModuleCreateInfo *>( pCreateInfo ),
27535 reinterpret_cast<VkShaderModuleIdentifierEXT *>( pIdentifier ) );
27536 }
27537
27538 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
27539 // wrapper function for command vkGetShaderModuleCreateInfoIdentifierEXT, see
27540 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderModuleCreateInfoIdentifierEXT.html
27541 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
27542 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ShaderModuleIdentifierEXT
27543 Device::getShaderModuleCreateInfoIdentifierEXT( const ShaderModuleCreateInfo & createInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
27544 {
27545 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
27546 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
27547 VULKAN_HPP_ASSERT( d.vkGetShaderModuleCreateInfoIdentifierEXT &&
27548 "Function <vkGetShaderModuleCreateInfoIdentifierEXT> requires <VK_EXT_shader_module_identifier>" );
27549 # endif
27550
27551 ShaderModuleIdentifierEXT identifier;
27552 d.vkGetShaderModuleCreateInfoIdentifierEXT(
27553 m_device, reinterpret_cast<const VkShaderModuleCreateInfo *>( &createInfo ), reinterpret_cast<VkShaderModuleIdentifierEXT *>( &identifier ) );
27554
27555 return identifier;
27556 }
27557 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
27558
27559 //=== VK_NV_optical_flow ===
27560
27561 // wrapper function for command vkGetPhysicalDeviceOpticalFlowImageFormatsNV, see
27562 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceOpticalFlowImageFormatsNV.html
27563 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
27564 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getOpticalFlowImageFormatsNV( const OpticalFlowImageFormatInfoNV * pOpticalFlowImageFormatInfo,
27565 uint32_t * pFormatCount,
27566 OpticalFlowImageFormatPropertiesNV * pImageFormatProperties,
27567 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
27568 {
27569 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
27570 return static_cast<Result>(
27571 d.vkGetPhysicalDeviceOpticalFlowImageFormatsNV( static_cast<VkPhysicalDevice>( m_physicalDevice ),
27572 reinterpret_cast<const VkOpticalFlowImageFormatInfoNV *>( pOpticalFlowImageFormatInfo ),
27573 pFormatCount,
27574 reinterpret_cast<VkOpticalFlowImageFormatPropertiesNV *>( pImageFormatProperties ) ) );
27575 }
27576
27577 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
27578 // wrapper function for command vkGetPhysicalDeviceOpticalFlowImageFormatsNV, see
27579 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceOpticalFlowImageFormatsNV.html
27580 template <typename OpticalFlowImageFormatPropertiesNVAllocator,
27581 typename Dispatch,
27582 typename std::enable_if<std::is_same<typename OpticalFlowImageFormatPropertiesNVAllocator::value_type, OpticalFlowImageFormatPropertiesNV>::value,
27583 int>::type,
27584 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
27585 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
27586 typename ResultValueType<std::vector<OpticalFlowImageFormatPropertiesNV, OpticalFlowImageFormatPropertiesNVAllocator>>::type
27587 PhysicalDevice::getOpticalFlowImageFormatsNV( const OpticalFlowImageFormatInfoNV & opticalFlowImageFormatInfo, Dispatch const & d ) const
27588 {
27589 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
27590 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
27591 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceOpticalFlowImageFormatsNV &&
27592 "Function <vkGetPhysicalDeviceOpticalFlowImageFormatsNV> requires <VK_NV_optical_flow>" );
27593 # endif
27594
27595 std::vector<OpticalFlowImageFormatPropertiesNV, OpticalFlowImageFormatPropertiesNVAllocator> imageFormatProperties;
27596 uint32_t formatCount;
27597 Result result;
27598 do
27599 {
27600 result = static_cast<Result>( d.vkGetPhysicalDeviceOpticalFlowImageFormatsNV(
27601 m_physicalDevice, reinterpret_cast<const VkOpticalFlowImageFormatInfoNV *>( &opticalFlowImageFormatInfo ), &formatCount, nullptr ) );
27602 if ( ( result == Result::eSuccess ) && formatCount )
27603 {
27604 imageFormatProperties.resize( formatCount );
27605 result = static_cast<Result>(
27606 d.vkGetPhysicalDeviceOpticalFlowImageFormatsNV( m_physicalDevice,
27607 reinterpret_cast<const VkOpticalFlowImageFormatInfoNV *>( &opticalFlowImageFormatInfo ),
27608 &formatCount,
27609 reinterpret_cast<VkOpticalFlowImageFormatPropertiesNV *>( imageFormatProperties.data() ) ) );
27610 }
27611 } while ( result == Result::eIncomplete );
27612 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getOpticalFlowImageFormatsNV" );
27613 VULKAN_HPP_ASSERT( formatCount <= imageFormatProperties.size() );
27614 if ( formatCount < imageFormatProperties.size() )
27615 {
27616 imageFormatProperties.resize( formatCount );
27617 }
27618 return detail::createResultValueType( result, std::move( imageFormatProperties ) );
27619 }
27620
27621 // wrapper function for command vkGetPhysicalDeviceOpticalFlowImageFormatsNV, see
27622 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceOpticalFlowImageFormatsNV.html
27623 template <typename OpticalFlowImageFormatPropertiesNVAllocator,
27624 typename Dispatch,
27625 typename std::enable_if<std::is_same<typename OpticalFlowImageFormatPropertiesNVAllocator::value_type, OpticalFlowImageFormatPropertiesNV>::value,
27626 int>::type,
27627 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
27628 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
27629 typename ResultValueType<std::vector<OpticalFlowImageFormatPropertiesNV, OpticalFlowImageFormatPropertiesNVAllocator>>::type
27630 PhysicalDevice::getOpticalFlowImageFormatsNV( const OpticalFlowImageFormatInfoNV & opticalFlowImageFormatInfo,
27631 OpticalFlowImageFormatPropertiesNVAllocator & opticalFlowImageFormatPropertiesNVAllocator,
27632 Dispatch const & d ) const
27633 {
27634 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
27635 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
27636 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceOpticalFlowImageFormatsNV &&
27637 "Function <vkGetPhysicalDeviceOpticalFlowImageFormatsNV> requires <VK_NV_optical_flow>" );
27638 # endif
27639
27640 std::vector<OpticalFlowImageFormatPropertiesNV, OpticalFlowImageFormatPropertiesNVAllocator> imageFormatProperties(
27641 opticalFlowImageFormatPropertiesNVAllocator );
27642 uint32_t formatCount;
27643 Result result;
27644 do
27645 {
27646 result = static_cast<Result>( d.vkGetPhysicalDeviceOpticalFlowImageFormatsNV(
27647 m_physicalDevice, reinterpret_cast<const VkOpticalFlowImageFormatInfoNV *>( &opticalFlowImageFormatInfo ), &formatCount, nullptr ) );
27648 if ( ( result == Result::eSuccess ) && formatCount )
27649 {
27650 imageFormatProperties.resize( formatCount );
27651 result = static_cast<Result>(
27652 d.vkGetPhysicalDeviceOpticalFlowImageFormatsNV( m_physicalDevice,
27653 reinterpret_cast<const VkOpticalFlowImageFormatInfoNV *>( &opticalFlowImageFormatInfo ),
27654 &formatCount,
27655 reinterpret_cast<VkOpticalFlowImageFormatPropertiesNV *>( imageFormatProperties.data() ) ) );
27656 }
27657 } while ( result == Result::eIncomplete );
27658 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getOpticalFlowImageFormatsNV" );
27659 VULKAN_HPP_ASSERT( formatCount <= imageFormatProperties.size() );
27660 if ( formatCount < imageFormatProperties.size() )
27661 {
27662 imageFormatProperties.resize( formatCount );
27663 }
27664 return detail::createResultValueType( result, std::move( imageFormatProperties ) );
27665 }
27666 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
27667
27668 // wrapper function for command vkCreateOpticalFlowSessionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateOpticalFlowSessionNV.html
27669 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
27670 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createOpticalFlowSessionNV( const OpticalFlowSessionCreateInfoNV * pCreateInfo,
27671 const AllocationCallbacks * pAllocator,
27672 OpticalFlowSessionNV * pSession,
27673 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
27674 {
27675 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
27676 return static_cast<Result>( d.vkCreateOpticalFlowSessionNV( static_cast<VkDevice>( m_device ),
27677 reinterpret_cast<const VkOpticalFlowSessionCreateInfoNV *>( pCreateInfo ),
27678 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
27679 reinterpret_cast<VkOpticalFlowSessionNV *>( pSession ) ) );
27680 }
27681
27682 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
27683 // wrapper function for command vkCreateOpticalFlowSessionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateOpticalFlowSessionNV.html
27684 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
27685 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<OpticalFlowSessionNV>::type Device::createOpticalFlowSessionNV(
27686 const OpticalFlowSessionCreateInfoNV & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
27687 {
27688 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
27689 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
27690 VULKAN_HPP_ASSERT( d.vkCreateOpticalFlowSessionNV && "Function <vkCreateOpticalFlowSessionNV> requires <VK_NV_optical_flow>" );
27691 # endif
27692
27693 OpticalFlowSessionNV session;
27694 Result result = static_cast<Result>( d.vkCreateOpticalFlowSessionNV( m_device,
27695 reinterpret_cast<const VkOpticalFlowSessionCreateInfoNV *>( &createInfo ),
27696 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
27697 reinterpret_cast<VkOpticalFlowSessionNV *>( &session ) ) );
27698 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createOpticalFlowSessionNV" );
27699
27700 return detail::createResultValueType( result, std::move( session ) );
27701 }
27702
27703 # ifndef VULKAN_HPP_NO_SMART_HANDLE
27704 // wrapper function for command vkCreateOpticalFlowSessionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateOpticalFlowSessionNV.html
27705 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
27706 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<OpticalFlowSessionNV, Dispatch>>::type Device::createOpticalFlowSessionNVUnique(
27707 const OpticalFlowSessionCreateInfoNV & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
27708 {
27709 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
27710 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
27711 VULKAN_HPP_ASSERT( d.vkCreateOpticalFlowSessionNV && "Function <vkCreateOpticalFlowSessionNV> requires <VK_NV_optical_flow>" );
27712 # endif
27713
27714 OpticalFlowSessionNV session;
27715 Result result = static_cast<Result>( d.vkCreateOpticalFlowSessionNV( m_device,
27716 reinterpret_cast<const VkOpticalFlowSessionCreateInfoNV *>( &createInfo ),
27717 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
27718 reinterpret_cast<VkOpticalFlowSessionNV *>( &session ) ) );
27719 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createOpticalFlowSessionNVUnique" );
27720
27721 return detail::createResultValueType(
27722 result, UniqueHandle<OpticalFlowSessionNV, Dispatch>( session, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
27723 }
27724 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
27725 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
27726
27727 // wrapper function for command vkDestroyOpticalFlowSessionNV, see
27728 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyOpticalFlowSessionNV.html
27729 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
27730 VULKAN_HPP_INLINE void
27731 Device::destroyOpticalFlowSessionNV( OpticalFlowSessionNV session, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
27732 {
27733 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
27734 d.vkDestroyOpticalFlowSessionNV(
27735 static_cast<VkDevice>( m_device ), static_cast<VkOpticalFlowSessionNV>( session ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
27736 }
27737
27738 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
27739 // wrapper function for command vkDestroyOpticalFlowSessionNV, see
27740 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyOpticalFlowSessionNV.html
27741 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
27742 VULKAN_HPP_INLINE void Device::destroyOpticalFlowSessionNV( OpticalFlowSessionNV session,
27743 Optional<const AllocationCallbacks> allocator,
27744 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
27745 {
27746 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
27747 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
27748 VULKAN_HPP_ASSERT( d.vkDestroyOpticalFlowSessionNV && "Function <vkDestroyOpticalFlowSessionNV> requires <VK_NV_optical_flow>" );
27749 # endif
27750
27751 d.vkDestroyOpticalFlowSessionNV(
27752 m_device, static_cast<VkOpticalFlowSessionNV>( session ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
27753 }
27754 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
27755
27756 // wrapper function for command vkDestroyOpticalFlowSessionNV, see
27757 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyOpticalFlowSessionNV.html
27758 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
27759 VULKAN_HPP_INLINE void Device::destroy( OpticalFlowSessionNV session, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
27760 {
27761 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
27762 d.vkDestroyOpticalFlowSessionNV(
27763 static_cast<VkDevice>( m_device ), static_cast<VkOpticalFlowSessionNV>( session ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
27764 }
27765
27766 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
27767 // wrapper function for command vkDestroyOpticalFlowSessionNV, see
27768 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyOpticalFlowSessionNV.html
27769 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
27770 VULKAN_HPP_INLINE void
27771 Device::destroy( OpticalFlowSessionNV session, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
27772 {
27773 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
27774 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
27775 VULKAN_HPP_ASSERT( d.vkDestroyOpticalFlowSessionNV && "Function <vkDestroyOpticalFlowSessionNV> requires <VK_NV_optical_flow>" );
27776 # endif
27777
27778 d.vkDestroyOpticalFlowSessionNV(
27779 m_device, static_cast<VkOpticalFlowSessionNV>( session ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
27780 }
27781 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
27782
27783 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
27784 // wrapper function for command vkBindOpticalFlowSessionImageNV, see
27785 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindOpticalFlowSessionImageNV.html
27786 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
27787 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::bindOpticalFlowSessionImageNV( OpticalFlowSessionNV session,
27788 OpticalFlowSessionBindingPointNV bindingPoint,
27789 ImageView view,
27790 ImageLayout layout,
27791 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
27792 {
27793 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
27794 return static_cast<Result>( d.vkBindOpticalFlowSessionImageNV( static_cast<VkDevice>( m_device ),
27795 static_cast<VkOpticalFlowSessionNV>( session ),
27796 static_cast<VkOpticalFlowSessionBindingPointNV>( bindingPoint ),
27797 static_cast<VkImageView>( view ),
27798 static_cast<VkImageLayout>( layout ) ) );
27799 }
27800 #else
27801 // wrapper function for command vkBindOpticalFlowSessionImageNV, see
27802 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindOpticalFlowSessionImageNV.html
27803 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
27804 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::bindOpticalFlowSessionImageNV(
27805 OpticalFlowSessionNV session, OpticalFlowSessionBindingPointNV bindingPoint, ImageView view, ImageLayout layout, Dispatch const & d ) const
27806 {
27807 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
27808 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
27809 VULKAN_HPP_ASSERT( d.vkBindOpticalFlowSessionImageNV && "Function <vkBindOpticalFlowSessionImageNV> requires <VK_NV_optical_flow>" );
27810 # endif
27811
27812 Result result = static_cast<Result>( d.vkBindOpticalFlowSessionImageNV( m_device,
27813 static_cast<VkOpticalFlowSessionNV>( session ),
27814 static_cast<VkOpticalFlowSessionBindingPointNV>( bindingPoint ),
27815 static_cast<VkImageView>( view ),
27816 static_cast<VkImageLayout>( layout ) ) );
27817 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindOpticalFlowSessionImageNV" );
27818
27819 return detail::createResultValueType( result );
27820 }
27821 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
27822
27823 // wrapper function for command vkCmdOpticalFlowExecuteNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdOpticalFlowExecuteNV.html
27824 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
27825 VULKAN_HPP_INLINE void CommandBuffer::opticalFlowExecuteNV( OpticalFlowSessionNV session,
27826 const OpticalFlowExecuteInfoNV * pExecuteInfo,
27827 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
27828 {
27829 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
27830 d.vkCmdOpticalFlowExecuteNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
27831 static_cast<VkOpticalFlowSessionNV>( session ),
27832 reinterpret_cast<const VkOpticalFlowExecuteInfoNV *>( pExecuteInfo ) );
27833 }
27834
27835 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
27836 // wrapper function for command vkCmdOpticalFlowExecuteNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdOpticalFlowExecuteNV.html
27837 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
27838 VULKAN_HPP_INLINE void CommandBuffer::opticalFlowExecuteNV( OpticalFlowSessionNV session,
27839 const OpticalFlowExecuteInfoNV & executeInfo,
27840 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
27841 {
27842 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
27843 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
27844 VULKAN_HPP_ASSERT( d.vkCmdOpticalFlowExecuteNV && "Function <vkCmdOpticalFlowExecuteNV> requires <VK_NV_optical_flow>" );
27845 # endif
27846
27847 d.vkCmdOpticalFlowExecuteNV(
27848 m_commandBuffer, static_cast<VkOpticalFlowSessionNV>( session ), reinterpret_cast<const VkOpticalFlowExecuteInfoNV *>( &executeInfo ) );
27849 }
27850 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
27851
27852 //=== VK_KHR_maintenance5 ===
27853
27854 // wrapper function for command vkCmdBindIndexBuffer2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindIndexBuffer2KHR.html
27855 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
27856 VULKAN_HPP_INLINE void
27857 CommandBuffer::bindIndexBuffer2KHR( Buffer buffer, DeviceSize offset, DeviceSize size, IndexType indexType, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
27858 {
27859 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
27860 d.vkCmdBindIndexBuffer2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
27861 static_cast<VkBuffer>( buffer ),
27862 static_cast<VkDeviceSize>( offset ),
27863 static_cast<VkDeviceSize>( size ),
27864 static_cast<VkIndexType>( indexType ) );
27865 }
27866
27867 // wrapper function for command vkGetRenderingAreaGranularityKHR, see
27868 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRenderingAreaGranularityKHR.html
27869 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
27870 VULKAN_HPP_INLINE void Device::getRenderingAreaGranularityKHR( const RenderingAreaInfo * pRenderingAreaInfo,
27871 Extent2D * pGranularity,
27872 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
27873 {
27874 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
27875 d.vkGetRenderingAreaGranularityKHR(
27876 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkRenderingAreaInfo *>( pRenderingAreaInfo ), reinterpret_cast<VkExtent2D *>( pGranularity ) );
27877 }
27878
27879 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
27880 // wrapper function for command vkGetRenderingAreaGranularityKHR, see
27881 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRenderingAreaGranularityKHR.html
27882 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
27883 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Extent2D Device::getRenderingAreaGranularityKHR( const RenderingAreaInfo & renderingAreaInfo,
27884 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
27885 {
27886 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
27887 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
27888 VULKAN_HPP_ASSERT( d.vkGetRenderingAreaGranularityKHR && "Function <vkGetRenderingAreaGranularityKHR> requires <VK_KHR_maintenance5> or <VK_VERSION_1_4>" );
27889 # endif
27890
27891 Extent2D granularity;
27892 d.vkGetRenderingAreaGranularityKHR(
27893 m_device, reinterpret_cast<const VkRenderingAreaInfo *>( &renderingAreaInfo ), reinterpret_cast<VkExtent2D *>( &granularity ) );
27894
27895 return granularity;
27896 }
27897 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
27898
27899 // wrapper function for command vkGetDeviceImageSubresourceLayoutKHR, see
27900 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSubresourceLayoutKHR.html
27901 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
27902 VULKAN_HPP_INLINE void
27903 Device::getImageSubresourceLayoutKHR( const DeviceImageSubresourceInfo * pInfo, SubresourceLayout2 * pLayout, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
27904 {
27905 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
27906 d.vkGetDeviceImageSubresourceLayoutKHR(
27907 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkDeviceImageSubresourceInfo *>( pInfo ), reinterpret_cast<VkSubresourceLayout2 *>( pLayout ) );
27908 }
27909
27910 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
27911 // wrapper function for command vkGetDeviceImageSubresourceLayoutKHR, see
27912 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSubresourceLayoutKHR.html
27913 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
27914 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE SubresourceLayout2 Device::getImageSubresourceLayoutKHR( const DeviceImageSubresourceInfo & info,
27915 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
27916 {
27917 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
27918 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
27919 VULKAN_HPP_ASSERT( d.vkGetDeviceImageSubresourceLayoutKHR &&
27920 "Function <vkGetDeviceImageSubresourceLayoutKHR> requires <VK_KHR_maintenance5> or <VK_VERSION_1_4>" );
27921 # endif
27922
27923 SubresourceLayout2 layout;
27924 d.vkGetDeviceImageSubresourceLayoutKHR(
27925 m_device, reinterpret_cast<const VkDeviceImageSubresourceInfo *>( &info ), reinterpret_cast<VkSubresourceLayout2 *>( &layout ) );
27926
27927 return layout;
27928 }
27929
27930 // wrapper function for command vkGetDeviceImageSubresourceLayoutKHR, see
27931 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSubresourceLayoutKHR.html
27932 template <typename X, typename Y, typename... Z, typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
27933 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getImageSubresourceLayoutKHR( const DeviceImageSubresourceInfo & info,
27934 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
27935 {
27936 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
27937 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
27938 VULKAN_HPP_ASSERT( d.vkGetDeviceImageSubresourceLayoutKHR &&
27939 "Function <vkGetDeviceImageSubresourceLayoutKHR> requires <VK_KHR_maintenance5> or <VK_VERSION_1_4>" );
27940 # endif
27941
27942 StructureChain<X, Y, Z...> structureChain;
27943 SubresourceLayout2 & layout = structureChain.template get<SubresourceLayout2>();
27944 d.vkGetDeviceImageSubresourceLayoutKHR(
27945 m_device, reinterpret_cast<const VkDeviceImageSubresourceInfo *>( &info ), reinterpret_cast<VkSubresourceLayout2 *>( &layout ) );
27946
27947 return structureChain;
27948 }
27949 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
27950
27951 // wrapper function for command vkGetImageSubresourceLayout2KHR, see
27952 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2KHR.html
27953 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
27954 VULKAN_HPP_INLINE void Device::getImageSubresourceLayout2KHR( Image image,
27955 const ImageSubresource2 * pSubresource,
27956 SubresourceLayout2 * pLayout,
27957 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
27958 {
27959 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
27960 d.vkGetImageSubresourceLayout2KHR( static_cast<VkDevice>( m_device ),
27961 static_cast<VkImage>( image ),
27962 reinterpret_cast<const VkImageSubresource2 *>( pSubresource ),
27963 reinterpret_cast<VkSubresourceLayout2 *>( pLayout ) );
27964 }
27965
27966 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
27967 // wrapper function for command vkGetImageSubresourceLayout2KHR, see
27968 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2KHR.html
27969 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
27970 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE SubresourceLayout2 Device::getImageSubresourceLayout2KHR( Image image,
27971 const ImageSubresource2 & subresource,
27972 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
27973 {
27974 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
27975 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
27976 VULKAN_HPP_ASSERT(
27977 d.vkGetImageSubresourceLayout2KHR &&
27978 "Function <vkGetImageSubresourceLayout2KHR> requires <VK_EXT_host_image_copy> or <VK_EXT_image_compression_control> or <VK_KHR_maintenance5> or <VK_VERSION_1_4>" );
27979 # endif
27980
27981 SubresourceLayout2 layout;
27982 d.vkGetImageSubresourceLayout2KHR( m_device,
27983 static_cast<VkImage>( image ),
27984 reinterpret_cast<const VkImageSubresource2 *>( &subresource ),
27985 reinterpret_cast<VkSubresourceLayout2 *>( &layout ) );
27986
27987 return layout;
27988 }
27989
27990 // wrapper function for command vkGetImageSubresourceLayout2KHR, see
27991 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2KHR.html
27992 template <typename X, typename Y, typename... Z, typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
27993 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...>
27994 Device::getImageSubresourceLayout2KHR( Image image, const ImageSubresource2 & subresource, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
27995 {
27996 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
27997 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
27998 VULKAN_HPP_ASSERT(
27999 d.vkGetImageSubresourceLayout2KHR &&
28000 "Function <vkGetImageSubresourceLayout2KHR> requires <VK_EXT_host_image_copy> or <VK_EXT_image_compression_control> or <VK_KHR_maintenance5> or <VK_VERSION_1_4>" );
28001 # endif
28002
28003 StructureChain<X, Y, Z...> structureChain;
28004 SubresourceLayout2 & layout = structureChain.template get<SubresourceLayout2>();
28005 d.vkGetImageSubresourceLayout2KHR( m_device,
28006 static_cast<VkImage>( image ),
28007 reinterpret_cast<const VkImageSubresource2 *>( &subresource ),
28008 reinterpret_cast<VkSubresourceLayout2 *>( &layout ) );
28009
28010 return structureChain;
28011 }
28012 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
28013
28014 //=== VK_AMD_anti_lag ===
28015
28016 // wrapper function for command vkAntiLagUpdateAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAntiLagUpdateAMD.html
28017 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
28018 VULKAN_HPP_INLINE void Device::antiLagUpdateAMD( const AntiLagDataAMD * pData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
28019 {
28020 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
28021 d.vkAntiLagUpdateAMD( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkAntiLagDataAMD *>( pData ) );
28022 }
28023
28024 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
28025 // wrapper function for command vkAntiLagUpdateAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAntiLagUpdateAMD.html
28026 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
28027 VULKAN_HPP_INLINE void Device::antiLagUpdateAMD( const AntiLagDataAMD & data, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
28028 {
28029 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
28030 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
28031 VULKAN_HPP_ASSERT( d.vkAntiLagUpdateAMD && "Function <vkAntiLagUpdateAMD> requires <VK_AMD_anti_lag>" );
28032 # endif
28033
28034 d.vkAntiLagUpdateAMD( m_device, reinterpret_cast<const VkAntiLagDataAMD *>( &data ) );
28035 }
28036 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
28037
28038 //=== VK_KHR_present_wait2 ===
28039
28040 // wrapper function for command vkWaitForPresent2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitForPresent2KHR.html
28041 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
28042 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::waitForPresent2KHR( SwapchainKHR swapchain,
28043 const PresentWait2InfoKHR * pPresentWait2Info,
28044 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
28045 {
28046 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
28047 return static_cast<Result>( d.vkWaitForPresent2KHR(
28048 static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<const VkPresentWait2InfoKHR *>( pPresentWait2Info ) ) );
28049 }
28050
28051 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
28052 // wrapper function for command vkWaitForPresent2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitForPresent2KHR.html
28053 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
28054 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::waitForPresent2KHR( SwapchainKHR swapchain,
28055 const PresentWait2InfoKHR & presentWait2Info,
28056 Dispatch const & d ) const
28057 {
28058 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
28059 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
28060 VULKAN_HPP_ASSERT( d.vkWaitForPresent2KHR && "Function <vkWaitForPresent2KHR> requires <VK_KHR_present_wait2>" );
28061 # endif
28062
28063 Result result = static_cast<Result>(
28064 d.vkWaitForPresent2KHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<const VkPresentWait2InfoKHR *>( &presentWait2Info ) ) );
28065
28066 # if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS )
28067 detail::resultCheck( result,
28068 VULKAN_HPP_NAMESPACE_STRING "::Device::waitForPresent2KHR",
28069 { Result::eSuccess, Result::eTimeout, Result::eSuboptimalKHR, Result::eErrorOutOfDateKHR } );
28070 # else
28071 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::waitForPresent2KHR", { Result::eSuccess, Result::eTimeout, Result::eSuboptimalKHR } );
28072 # endif
28073
28074 return static_cast<Result>( result );
28075 }
28076 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
28077
28078 //=== VK_EXT_shader_object ===
28079
28080 // wrapper function for command vkCreateShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShadersEXT.html
28081 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
28082 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createShadersEXT( uint32_t createInfoCount,
28083 const ShaderCreateInfoEXT * pCreateInfos,
28084 const AllocationCallbacks * pAllocator,
28085 ShaderEXT * pShaders,
28086 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
28087 {
28088 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
28089 return static_cast<Result>( d.vkCreateShadersEXT( static_cast<VkDevice>( m_device ),
28090 createInfoCount,
28091 reinterpret_cast<const VkShaderCreateInfoEXT *>( pCreateInfos ),
28092 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
28093 reinterpret_cast<VkShaderEXT *>( pShaders ) ) );
28094 }
28095
28096 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
28097 // wrapper function for command vkCreateShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShadersEXT.html
28098 template <typename ShaderEXTAllocator,
28099 typename Dispatch,
28100 typename std::enable_if<std::is_same<typename ShaderEXTAllocator::value_type, ShaderEXT>::value, int>::type,
28101 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
28102 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<ShaderEXT, ShaderEXTAllocator>> Device::createShadersEXT(
28103 ArrayProxy<const ShaderCreateInfoEXT> const & createInfos, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
28104 {
28105 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
28106 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
28107 VULKAN_HPP_ASSERT( d.vkCreateShadersEXT && "Function <vkCreateShadersEXT> requires <VK_EXT_shader_object>" );
28108 # endif
28109
28110 std::vector<ShaderEXT, ShaderEXTAllocator> shaders( createInfos.size() );
28111 Result result = static_cast<Result>( d.vkCreateShadersEXT( m_device,
28112 createInfos.size(),
28113 reinterpret_cast<const VkShaderCreateInfoEXT *>( createInfos.data() ),
28114 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
28115 reinterpret_cast<VkShaderEXT *>( shaders.data() ) ) );
28116 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createShadersEXT", { Result::eSuccess, Result::eIncompatibleShaderBinaryEXT } );
28117
28118 return ResultValue<std::vector<ShaderEXT, ShaderEXTAllocator>>( result, std::move( shaders ) );
28119 }
28120
28121 // wrapper function for command vkCreateShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShadersEXT.html
28122 template <typename ShaderEXTAllocator,
28123 typename Dispatch,
28124 typename std::enable_if<std::is_same<typename ShaderEXTAllocator::value_type, ShaderEXT>::value, int>::type,
28125 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
28126 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<ShaderEXT, ShaderEXTAllocator>>
28127 Device::createShadersEXT( ArrayProxy<const ShaderCreateInfoEXT> const & createInfos,
28128 Optional<const AllocationCallbacks> allocator,
28129 ShaderEXTAllocator & shaderEXTAllocator,
28130 Dispatch const & d ) const
28131 {
28132 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
28133 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
28134 VULKAN_HPP_ASSERT( d.vkCreateShadersEXT && "Function <vkCreateShadersEXT> requires <VK_EXT_shader_object>" );
28135 # endif
28136
28137 std::vector<ShaderEXT, ShaderEXTAllocator> shaders( createInfos.size(), shaderEXTAllocator );
28138 Result result = static_cast<Result>( d.vkCreateShadersEXT( m_device,
28139 createInfos.size(),
28140 reinterpret_cast<const VkShaderCreateInfoEXT *>( createInfos.data() ),
28141 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
28142 reinterpret_cast<VkShaderEXT *>( shaders.data() ) ) );
28143 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createShadersEXT", { Result::eSuccess, Result::eIncompatibleShaderBinaryEXT } );
28144
28145 return ResultValue<std::vector<ShaderEXT, ShaderEXTAllocator>>( result, std::move( shaders ) );
28146 }
28147
28148 // wrapper function for command vkCreateShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShadersEXT.html
28149 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
28150 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<ShaderEXT>
28151 Device::createShaderEXT( const ShaderCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
28152 {
28153 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
28154 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
28155 VULKAN_HPP_ASSERT( d.vkCreateShadersEXT && "Function <vkCreateShadersEXT> requires <VK_EXT_shader_object>" );
28156 # endif
28157
28158 ShaderEXT shader;
28159 Result result = static_cast<Result>( d.vkCreateShadersEXT( m_device,
28160 1,
28161 reinterpret_cast<const VkShaderCreateInfoEXT *>( &createInfo ),
28162 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
28163 reinterpret_cast<VkShaderEXT *>( &shader ) ) );
28164 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createShaderEXT", { Result::eSuccess, Result::eIncompatibleShaderBinaryEXT } );
28165
28166 return ResultValue<ShaderEXT>( result, std::move( shader ) );
28167 }
28168
28169 # ifndef VULKAN_HPP_NO_SMART_HANDLE
28170 // wrapper function for command vkCreateShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShadersEXT.html
28171 template <typename Dispatch,
28172 typename ShaderEXTAllocator,
28173 typename std::enable_if<std::is_same<typename ShaderEXTAllocator::value_type, UniqueHandle<ShaderEXT, Dispatch>>::value, int>::type,
28174 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
28175 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<ShaderEXT, Dispatch>, ShaderEXTAllocator>> Device::createShadersEXTUnique(
28176 ArrayProxy<const ShaderCreateInfoEXT> const & createInfos, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
28177 {
28178 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
28179 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
28180 VULKAN_HPP_ASSERT( d.vkCreateShadersEXT && "Function <vkCreateShadersEXT> requires <VK_EXT_shader_object>" );
28181 # endif
28182
28183 std::vector<ShaderEXT> shaders( createInfos.size() );
28184 Result result = static_cast<Result>( d.vkCreateShadersEXT( m_device,
28185 createInfos.size(),
28186 reinterpret_cast<const VkShaderCreateInfoEXT *>( createInfos.data() ),
28187 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
28188 reinterpret_cast<VkShaderEXT *>( shaders.data() ) ) );
28189 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createShadersEXTUnique", { Result::eSuccess, Result::eIncompatibleShaderBinaryEXT } );
28190 std::vector<UniqueHandle<ShaderEXT, Dispatch>, ShaderEXTAllocator> uniqueShaders;
28191 uniqueShaders.reserve( createInfos.size() );
28192 detail::ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
28193 for ( auto const & shader : shaders )
28194 {
28195 uniqueShaders.push_back( UniqueHandle<ShaderEXT, Dispatch>( shader, deleter ) );
28196 }
28197 return ResultValue<std::vector<UniqueHandle<ShaderEXT, Dispatch>, ShaderEXTAllocator>>( result, std::move( uniqueShaders ) );
28198 }
28199
28200 // wrapper function for command vkCreateShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShadersEXT.html
28201 template <typename Dispatch,
28202 typename ShaderEXTAllocator,
28203 typename std::enable_if<std::is_same<typename ShaderEXTAllocator::value_type, UniqueHandle<ShaderEXT, Dispatch>>::value, int>::type,
28204 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
28205 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<ShaderEXT, Dispatch>, ShaderEXTAllocator>>
28206 Device::createShadersEXTUnique( ArrayProxy<const ShaderCreateInfoEXT> const & createInfos,
28207 Optional<const AllocationCallbacks> allocator,
28208 ShaderEXTAllocator & shaderEXTAllocator,
28209 Dispatch const & d ) const
28210 {
28211 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
28212 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
28213 VULKAN_HPP_ASSERT( d.vkCreateShadersEXT && "Function <vkCreateShadersEXT> requires <VK_EXT_shader_object>" );
28214 # endif
28215
28216 std::vector<ShaderEXT> shaders( createInfos.size() );
28217 Result result = static_cast<Result>( d.vkCreateShadersEXT( m_device,
28218 createInfos.size(),
28219 reinterpret_cast<const VkShaderCreateInfoEXT *>( createInfos.data() ),
28220 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
28221 reinterpret_cast<VkShaderEXT *>( shaders.data() ) ) );
28222 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createShadersEXTUnique", { Result::eSuccess, Result::eIncompatibleShaderBinaryEXT } );
28223 std::vector<UniqueHandle<ShaderEXT, Dispatch>, ShaderEXTAllocator> uniqueShaders( shaderEXTAllocator );
28224 uniqueShaders.reserve( createInfos.size() );
28225 detail::ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
28226 for ( auto const & shader : shaders )
28227 {
28228 uniqueShaders.push_back( UniqueHandle<ShaderEXT, Dispatch>( shader, deleter ) );
28229 }
28230 return ResultValue<std::vector<UniqueHandle<ShaderEXT, Dispatch>, ShaderEXTAllocator>>( result, std::move( uniqueShaders ) );
28231 }
28232
28233 // wrapper function for command vkCreateShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShadersEXT.html
28234 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
28235 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<UniqueHandle<ShaderEXT, Dispatch>>
28236 Device::createShaderEXTUnique( const ShaderCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
28237 {
28238 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
28239 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
28240 VULKAN_HPP_ASSERT( d.vkCreateShadersEXT && "Function <vkCreateShadersEXT> requires <VK_EXT_shader_object>" );
28241 # endif
28242
28243 ShaderEXT shader;
28244 Result result = static_cast<Result>( d.vkCreateShadersEXT( m_device,
28245 1,
28246 reinterpret_cast<const VkShaderCreateInfoEXT *>( &createInfo ),
28247 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
28248 reinterpret_cast<VkShaderEXT *>( &shader ) ) );
28249 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createShaderEXTUnique", { Result::eSuccess, Result::eIncompatibleShaderBinaryEXT } );
28250
28251 return ResultValue<UniqueHandle<ShaderEXT, Dispatch>>(
28252 result, UniqueHandle<ShaderEXT, Dispatch>( shader, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
28253 }
28254 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
28255 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
28256
28257 // wrapper function for command vkDestroyShaderEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyShaderEXT.html
28258 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
28259 VULKAN_HPP_INLINE void Device::destroyShaderEXT( ShaderEXT shader, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
28260 {
28261 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
28262 d.vkDestroyShaderEXT(
28263 static_cast<VkDevice>( m_device ), static_cast<VkShaderEXT>( shader ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
28264 }
28265
28266 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
28267 // wrapper function for command vkDestroyShaderEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyShaderEXT.html
28268 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
28269 VULKAN_HPP_INLINE void
28270 Device::destroyShaderEXT( ShaderEXT shader, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
28271 {
28272 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
28273 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
28274 VULKAN_HPP_ASSERT( d.vkDestroyShaderEXT && "Function <vkDestroyShaderEXT> requires <VK_EXT_shader_object>" );
28275 # endif
28276
28277 d.vkDestroyShaderEXT( m_device, static_cast<VkShaderEXT>( shader ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
28278 }
28279 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
28280
28281 // wrapper function for command vkDestroyShaderEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyShaderEXT.html
28282 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
28283 VULKAN_HPP_INLINE void Device::destroy( ShaderEXT shader, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
28284 {
28285 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
28286 d.vkDestroyShaderEXT(
28287 static_cast<VkDevice>( m_device ), static_cast<VkShaderEXT>( shader ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
28288 }
28289
28290 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
28291 // wrapper function for command vkDestroyShaderEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyShaderEXT.html
28292 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
28293 VULKAN_HPP_INLINE void Device::destroy( ShaderEXT shader, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
28294 {
28295 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
28296 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
28297 VULKAN_HPP_ASSERT( d.vkDestroyShaderEXT && "Function <vkDestroyShaderEXT> requires <VK_EXT_shader_object>" );
28298 # endif
28299
28300 d.vkDestroyShaderEXT( m_device, static_cast<VkShaderEXT>( shader ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
28301 }
28302 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
28303
28304 // wrapper function for command vkGetShaderBinaryDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderBinaryDataEXT.html
28305 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
28306 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
28307 Device::getShaderBinaryDataEXT( ShaderEXT shader, size_t * pDataSize, void * pData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
28308 {
28309 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
28310 return static_cast<Result>( d.vkGetShaderBinaryDataEXT( static_cast<VkDevice>( m_device ), static_cast<VkShaderEXT>( shader ), pDataSize, pData ) );
28311 }
28312
28313 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
28314 // wrapper function for command vkGetShaderBinaryDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderBinaryDataEXT.html
28315 template <typename Uint8_tAllocator,
28316 typename Dispatch,
28317 typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type,
28318 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
28319 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
28320 Device::getShaderBinaryDataEXT( ShaderEXT shader, Dispatch const & d ) const
28321 {
28322 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
28323 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
28324 VULKAN_HPP_ASSERT( d.vkGetShaderBinaryDataEXT && "Function <vkGetShaderBinaryDataEXT> requires <VK_EXT_shader_object>" );
28325 # endif
28326
28327 std::vector<uint8_t, Uint8_tAllocator> data;
28328 size_t dataSize;
28329 Result result;
28330 do
28331 {
28332 result = static_cast<Result>( d.vkGetShaderBinaryDataEXT( m_device, static_cast<VkShaderEXT>( shader ), &dataSize, nullptr ) );
28333 if ( ( result == Result::eSuccess ) && dataSize )
28334 {
28335 data.resize( dataSize );
28336 result =
28337 static_cast<Result>( d.vkGetShaderBinaryDataEXT( m_device, static_cast<VkShaderEXT>( shader ), &dataSize, reinterpret_cast<void *>( data.data() ) ) );
28338 }
28339 } while ( result == Result::eIncomplete );
28340 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getShaderBinaryDataEXT" );
28341 VULKAN_HPP_ASSERT( dataSize <= data.size() );
28342 if ( dataSize < data.size() )
28343 {
28344 data.resize( dataSize );
28345 }
28346 return detail::createResultValueType( result, std::move( data ) );
28347 }
28348
28349 // wrapper function for command vkGetShaderBinaryDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderBinaryDataEXT.html
28350 template <typename Uint8_tAllocator,
28351 typename Dispatch,
28352 typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type,
28353 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
28354 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
28355 Device::getShaderBinaryDataEXT( ShaderEXT shader, Uint8_tAllocator & uint8_tAllocator, Dispatch const & d ) const
28356 {
28357 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
28358 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
28359 VULKAN_HPP_ASSERT( d.vkGetShaderBinaryDataEXT && "Function <vkGetShaderBinaryDataEXT> requires <VK_EXT_shader_object>" );
28360 # endif
28361
28362 std::vector<uint8_t, Uint8_tAllocator> data( uint8_tAllocator );
28363 size_t dataSize;
28364 Result result;
28365 do
28366 {
28367 result = static_cast<Result>( d.vkGetShaderBinaryDataEXT( m_device, static_cast<VkShaderEXT>( shader ), &dataSize, nullptr ) );
28368 if ( ( result == Result::eSuccess ) && dataSize )
28369 {
28370 data.resize( dataSize );
28371 result =
28372 static_cast<Result>( d.vkGetShaderBinaryDataEXT( m_device, static_cast<VkShaderEXT>( shader ), &dataSize, reinterpret_cast<void *>( data.data() ) ) );
28373 }
28374 } while ( result == Result::eIncomplete );
28375 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getShaderBinaryDataEXT" );
28376 VULKAN_HPP_ASSERT( dataSize <= data.size() );
28377 if ( dataSize < data.size() )
28378 {
28379 data.resize( dataSize );
28380 }
28381 return detail::createResultValueType( result, std::move( data ) );
28382 }
28383 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
28384
28385 // wrapper function for command vkCmdBindShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindShadersEXT.html
28386 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
28387 VULKAN_HPP_INLINE void CommandBuffer::bindShadersEXT( uint32_t stageCount,
28388 const ShaderStageFlagBits * pStages,
28389 const ShaderEXT * pShaders,
28390 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
28391 {
28392 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
28393 d.vkCmdBindShadersEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
28394 stageCount,
28395 reinterpret_cast<const VkShaderStageFlagBits *>( pStages ),
28396 reinterpret_cast<const VkShaderEXT *>( pShaders ) );
28397 }
28398
28399 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
28400 // wrapper function for command vkCmdBindShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindShadersEXT.html
28401 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
28402 VULKAN_HPP_INLINE void CommandBuffer::bindShadersEXT( ArrayProxy<const ShaderStageFlagBits> const & stages,
28403 ArrayProxy<const ShaderEXT> const & shaders,
28404 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
28405 {
28406 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
28407 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
28408 VULKAN_HPP_ASSERT( d.vkCmdBindShadersEXT && "Function <vkCmdBindShadersEXT> requires <VK_EXT_shader_object>" );
28409 # endif
28410 # ifdef VULKAN_HPP_NO_EXCEPTIONS
28411 VULKAN_HPP_ASSERT( stages.size() == shaders.size() );
28412 # else
28413 if ( stages.size() != shaders.size() )
28414 {
28415 throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindShadersEXT: stages.size() != shaders.size()" );
28416 }
28417 # endif /*VULKAN_HPP_NO_EXCEPTIONS*/
28418
28419 d.vkCmdBindShadersEXT( m_commandBuffer,
28420 stages.size(),
28421 reinterpret_cast<const VkShaderStageFlagBits *>( stages.data() ),
28422 reinterpret_cast<const VkShaderEXT *>( shaders.data() ) );
28423 }
28424 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
28425
28426 // wrapper function for command vkCmdSetDepthClampRangeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthClampRangeEXT.html
28427 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
28428 VULKAN_HPP_INLINE void CommandBuffer::setDepthClampRangeEXT( DepthClampModeEXT depthClampMode,
28429 const DepthClampRangeEXT * pDepthClampRange,
28430 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
28431 {
28432 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
28433 d.vkCmdSetDepthClampRangeEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
28434 static_cast<VkDepthClampModeEXT>( depthClampMode ),
28435 reinterpret_cast<const VkDepthClampRangeEXT *>( pDepthClampRange ) );
28436 }
28437
28438 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
28439 // wrapper function for command vkCmdSetDepthClampRangeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthClampRangeEXT.html
28440 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
28441 VULKAN_HPP_INLINE void CommandBuffer::setDepthClampRangeEXT( DepthClampModeEXT depthClampMode,
28442 Optional<const DepthClampRangeEXT> depthClampRange,
28443 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
28444 {
28445 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
28446 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
28447 VULKAN_HPP_ASSERT( d.vkCmdSetDepthClampRangeEXT &&
28448 "Function <vkCmdSetDepthClampRangeEXT> requires <VK_EXT_depth_clamp_control> or <VK_EXT_shader_object>" );
28449 # endif
28450
28451 d.vkCmdSetDepthClampRangeEXT(
28452 m_commandBuffer, static_cast<VkDepthClampModeEXT>( depthClampMode ), reinterpret_cast<const VkDepthClampRangeEXT *>( depthClampRange.get() ) );
28453 }
28454 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
28455
28456 //=== VK_KHR_pipeline_binary ===
28457
28458 // wrapper function for command vkCreatePipelineBinariesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineBinariesKHR.html
28459 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
28460 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createPipelineBinariesKHR( const PipelineBinaryCreateInfoKHR * pCreateInfo,
28461 const AllocationCallbacks * pAllocator,
28462 PipelineBinaryHandlesInfoKHR * pBinaries,
28463 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
28464 {
28465 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
28466 return static_cast<Result>( d.vkCreatePipelineBinariesKHR( static_cast<VkDevice>( m_device ),
28467 reinterpret_cast<const VkPipelineBinaryCreateInfoKHR *>( pCreateInfo ),
28468 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
28469 reinterpret_cast<VkPipelineBinaryHandlesInfoKHR *>( pBinaries ) ) );
28470 }
28471
28472 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
28473 // wrapper function for command vkCreatePipelineBinariesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineBinariesKHR.html
28474 template <typename PipelineBinaryKHRAllocator,
28475 typename Dispatch,
28476 typename std::enable_if<std::is_same<typename PipelineBinaryKHRAllocator::value_type, PipelineBinaryKHR>::value, int>::type,
28477 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
28478 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<PipelineBinaryKHR, PipelineBinaryKHRAllocator>>
28479 Device::createPipelineBinariesKHR( const PipelineBinaryCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
28480 {
28481 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
28482 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
28483 VULKAN_HPP_ASSERT( d.vkCreatePipelineBinariesKHR && "Function <vkCreatePipelineBinariesKHR> requires <VK_KHR_pipeline_binary>" );
28484 # endif
28485
28486 std::vector<PipelineBinaryKHR, PipelineBinaryKHRAllocator> pipelineBinaries;
28487 PipelineBinaryHandlesInfoKHR binaries;
28488 Result result;
28489 if ( createInfo.pKeysAndDataInfo )
28490 {
28491 VULKAN_HPP_ASSERT( !createInfo.pipeline && !createInfo.pPipelineCreateInfo );
28492 pipelineBinaries.resize( createInfo.pKeysAndDataInfo->binaryCount );
28493 binaries.pipelineBinaryCount = createInfo.pKeysAndDataInfo->binaryCount;
28494 binaries.pPipelineBinaries = pipelineBinaries.data();
28495 result = static_cast<Result>( d.vkCreatePipelineBinariesKHR( m_device,
28496 reinterpret_cast<const VkPipelineBinaryCreateInfoKHR *>( &createInfo ),
28497 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
28498 reinterpret_cast<VkPipelineBinaryHandlesInfoKHR *>( &binaries ) ) );
28499 }
28500 else
28501 {
28502 VULKAN_HPP_ASSERT( !createInfo.pipeline ^ !createInfo.pPipelineCreateInfo );
28503 result = static_cast<Result>( d.vkCreatePipelineBinariesKHR( m_device,
28504 reinterpret_cast<const VkPipelineBinaryCreateInfoKHR *>( &createInfo ),
28505 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
28506 reinterpret_cast<VkPipelineBinaryHandlesInfoKHR *>( &binaries ) ) );
28507 if ( result == Result::eSuccess )
28508 {
28509 pipelineBinaries.resize( binaries.pipelineBinaryCount );
28510 binaries.pPipelineBinaries = pipelineBinaries.data();
28511 result = static_cast<Result>( d.vkCreatePipelineBinariesKHR( m_device,
28512 reinterpret_cast<const VkPipelineBinaryCreateInfoKHR *>( &createInfo ),
28513 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
28514 reinterpret_cast<VkPipelineBinaryHandlesInfoKHR *>( &binaries ) ) );
28515 }
28516 }
28517
28518 detail::resultCheck(
28519 result, VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineBinariesKHR", { Result::eSuccess, Result::eIncomplete, Result::ePipelineBinaryMissingKHR } );
28520
28521 return ResultValue<std::vector<PipelineBinaryKHR, PipelineBinaryKHRAllocator>>( result, std::move( pipelineBinaries ) );
28522 }
28523
28524 // wrapper function for command vkCreatePipelineBinariesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineBinariesKHR.html
28525 template <typename PipelineBinaryKHRAllocator,
28526 typename Dispatch,
28527 typename std::enable_if<std::is_same<typename PipelineBinaryKHRAllocator::value_type, PipelineBinaryKHR>::value, int>::type,
28528 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
28529 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<PipelineBinaryKHR, PipelineBinaryKHRAllocator>>
28530 Device::createPipelineBinariesKHR( const PipelineBinaryCreateInfoKHR & createInfo,
28531 Optional<const AllocationCallbacks> allocator,
28532 PipelineBinaryKHRAllocator & pipelineBinaryKHRAllocator,
28533 Dispatch const & d ) const
28534 {
28535 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
28536 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
28537 VULKAN_HPP_ASSERT( d.vkCreatePipelineBinariesKHR && "Function <vkCreatePipelineBinariesKHR> requires <VK_KHR_pipeline_binary>" );
28538 # endif
28539
28540 std::vector<PipelineBinaryKHR, PipelineBinaryKHRAllocator> pipelineBinaries( pipelineBinaryKHRAllocator );
28541 PipelineBinaryHandlesInfoKHR binaries;
28542 Result result;
28543 if ( createInfo.pKeysAndDataInfo )
28544 {
28545 VULKAN_HPP_ASSERT( !createInfo.pipeline && !createInfo.pPipelineCreateInfo );
28546 pipelineBinaries.resize( createInfo.pKeysAndDataInfo->binaryCount );
28547 binaries.pipelineBinaryCount = createInfo.pKeysAndDataInfo->binaryCount;
28548 binaries.pPipelineBinaries = pipelineBinaries.data();
28549 result = static_cast<Result>( d.vkCreatePipelineBinariesKHR( m_device,
28550 reinterpret_cast<const VkPipelineBinaryCreateInfoKHR *>( &createInfo ),
28551 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
28552 reinterpret_cast<VkPipelineBinaryHandlesInfoKHR *>( &binaries ) ) );
28553 }
28554 else
28555 {
28556 VULKAN_HPP_ASSERT( !createInfo.pipeline ^ !createInfo.pPipelineCreateInfo );
28557 result = static_cast<Result>( d.vkCreatePipelineBinariesKHR( m_device,
28558 reinterpret_cast<const VkPipelineBinaryCreateInfoKHR *>( &createInfo ),
28559 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
28560 reinterpret_cast<VkPipelineBinaryHandlesInfoKHR *>( &binaries ) ) );
28561 if ( result == Result::eSuccess )
28562 {
28563 pipelineBinaries.resize( binaries.pipelineBinaryCount );
28564 binaries.pPipelineBinaries = pipelineBinaries.data();
28565 result = static_cast<Result>( d.vkCreatePipelineBinariesKHR( m_device,
28566 reinterpret_cast<const VkPipelineBinaryCreateInfoKHR *>( &createInfo ),
28567 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
28568 reinterpret_cast<VkPipelineBinaryHandlesInfoKHR *>( &binaries ) ) );
28569 }
28570 }
28571
28572 detail::resultCheck(
28573 result, VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineBinariesKHR", { Result::eSuccess, Result::eIncomplete, Result::ePipelineBinaryMissingKHR } );
28574
28575 return ResultValue<std::vector<PipelineBinaryKHR, PipelineBinaryKHRAllocator>>( result, std::move( pipelineBinaries ) );
28576 }
28577
28578 # ifndef VULKAN_HPP_NO_SMART_HANDLE
28579 // wrapper function for command vkCreatePipelineBinariesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineBinariesKHR.html
28580 template <typename Dispatch,
28581 typename PipelineBinaryKHRAllocator,
28582 typename std::enable_if<std::is_same<typename PipelineBinaryKHRAllocator::value_type, UniqueHandle<PipelineBinaryKHR, Dispatch>>::value, int>::type,
28583 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
28584 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<PipelineBinaryKHR, Dispatch>, PipelineBinaryKHRAllocator>>
28585 Device::createPipelineBinariesKHRUnique( const PipelineBinaryCreateInfoKHR & createInfo,
28586 Optional<const AllocationCallbacks> allocator,
28587 Dispatch const & d ) const
28588 {
28589 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
28590 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
28591 VULKAN_HPP_ASSERT( d.vkCreatePipelineBinariesKHR && "Function <vkCreatePipelineBinariesKHR> requires <VK_KHR_pipeline_binary>" );
28592 # endif
28593
28594 std::vector<PipelineBinaryKHR> pipelineBinaries;
28595 PipelineBinaryHandlesInfoKHR binaries;
28596 Result result;
28597 if ( createInfo.pKeysAndDataInfo )
28598 {
28599 VULKAN_HPP_ASSERT( !createInfo.pipeline && !createInfo.pPipelineCreateInfo );
28600 pipelineBinaries.resize( createInfo.pKeysAndDataInfo->binaryCount );
28601 binaries.pipelineBinaryCount = createInfo.pKeysAndDataInfo->binaryCount;
28602 binaries.pPipelineBinaries = pipelineBinaries.data();
28603 result = static_cast<Result>( d.vkCreatePipelineBinariesKHR( m_device,
28604 reinterpret_cast<const VkPipelineBinaryCreateInfoKHR *>( &createInfo ),
28605 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
28606 reinterpret_cast<VkPipelineBinaryHandlesInfoKHR *>( &binaries ) ) );
28607 }
28608 else
28609 {
28610 VULKAN_HPP_ASSERT( !createInfo.pipeline ^ !createInfo.pPipelineCreateInfo );
28611 result = static_cast<Result>( d.vkCreatePipelineBinariesKHR( m_device,
28612 reinterpret_cast<const VkPipelineBinaryCreateInfoKHR *>( &createInfo ),
28613 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
28614 reinterpret_cast<VkPipelineBinaryHandlesInfoKHR *>( &binaries ) ) );
28615 if ( result == Result::eSuccess )
28616 {
28617 pipelineBinaries.resize( binaries.pipelineBinaryCount );
28618 binaries.pPipelineBinaries = pipelineBinaries.data();
28619 result = static_cast<Result>( d.vkCreatePipelineBinariesKHR( m_device,
28620 reinterpret_cast<const VkPipelineBinaryCreateInfoKHR *>( &createInfo ),
28621 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
28622 reinterpret_cast<VkPipelineBinaryHandlesInfoKHR *>( &binaries ) ) );
28623 }
28624 }
28625
28626 detail::resultCheck( result,
28627 VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineBinariesKHRUnique",
28628 { Result::eSuccess, Result::eIncomplete, Result::ePipelineBinaryMissingKHR } );
28629 std::vector<UniqueHandle<PipelineBinaryKHR, Dispatch>, PipelineBinaryKHRAllocator> uniquePipelineBinaries;
28630 uniquePipelineBinaries.reserve( pipelineBinaries.size() );
28631 detail::ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
28632 for ( auto const & pipelineBinary : pipelineBinaries )
28633 {
28634 uniquePipelineBinaries.push_back( UniqueHandle<PipelineBinaryKHR, Dispatch>( pipelineBinary, deleter ) );
28635 }
28636 return ResultValue<std::vector<UniqueHandle<PipelineBinaryKHR, Dispatch>, PipelineBinaryKHRAllocator>>( result, std::move( uniquePipelineBinaries ) );
28637 }
28638
28639 // wrapper function for command vkCreatePipelineBinariesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineBinariesKHR.html
28640 template <typename Dispatch,
28641 typename PipelineBinaryKHRAllocator,
28642 typename std::enable_if<std::is_same<typename PipelineBinaryKHRAllocator::value_type, UniqueHandle<PipelineBinaryKHR, Dispatch>>::value, int>::type,
28643 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
28644 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<PipelineBinaryKHR, Dispatch>, PipelineBinaryKHRAllocator>>
28645 Device::createPipelineBinariesKHRUnique( const PipelineBinaryCreateInfoKHR & createInfo,
28646 Optional<const AllocationCallbacks> allocator,
28647 PipelineBinaryKHRAllocator & pipelineBinaryKHRAllocator,
28648 Dispatch const & d ) const
28649 {
28650 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
28651 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
28652 VULKAN_HPP_ASSERT( d.vkCreatePipelineBinariesKHR && "Function <vkCreatePipelineBinariesKHR> requires <VK_KHR_pipeline_binary>" );
28653 # endif
28654
28655 std::vector<PipelineBinaryKHR> pipelineBinaries;
28656 PipelineBinaryHandlesInfoKHR binaries;
28657 Result result;
28658 if ( createInfo.pKeysAndDataInfo )
28659 {
28660 VULKAN_HPP_ASSERT( !createInfo.pipeline && !createInfo.pPipelineCreateInfo );
28661 pipelineBinaries.resize( createInfo.pKeysAndDataInfo->binaryCount );
28662 binaries.pipelineBinaryCount = createInfo.pKeysAndDataInfo->binaryCount;
28663 binaries.pPipelineBinaries = pipelineBinaries.data();
28664 result = static_cast<Result>( d.vkCreatePipelineBinariesKHR( m_device,
28665 reinterpret_cast<const VkPipelineBinaryCreateInfoKHR *>( &createInfo ),
28666 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
28667 reinterpret_cast<VkPipelineBinaryHandlesInfoKHR *>( &binaries ) ) );
28668 }
28669 else
28670 {
28671 VULKAN_HPP_ASSERT( !createInfo.pipeline ^ !createInfo.pPipelineCreateInfo );
28672 result = static_cast<Result>( d.vkCreatePipelineBinariesKHR( m_device,
28673 reinterpret_cast<const VkPipelineBinaryCreateInfoKHR *>( &createInfo ),
28674 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
28675 reinterpret_cast<VkPipelineBinaryHandlesInfoKHR *>( &binaries ) ) );
28676 if ( result == Result::eSuccess )
28677 {
28678 pipelineBinaries.resize( binaries.pipelineBinaryCount );
28679 binaries.pPipelineBinaries = pipelineBinaries.data();
28680 result = static_cast<Result>( d.vkCreatePipelineBinariesKHR( m_device,
28681 reinterpret_cast<const VkPipelineBinaryCreateInfoKHR *>( &createInfo ),
28682 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
28683 reinterpret_cast<VkPipelineBinaryHandlesInfoKHR *>( &binaries ) ) );
28684 }
28685 }
28686
28687 detail::resultCheck( result,
28688 VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineBinariesKHRUnique",
28689 { Result::eSuccess, Result::eIncomplete, Result::ePipelineBinaryMissingKHR } );
28690 std::vector<UniqueHandle<PipelineBinaryKHR, Dispatch>, PipelineBinaryKHRAllocator> uniquePipelineBinaries( pipelineBinaryKHRAllocator );
28691 uniquePipelineBinaries.reserve( pipelineBinaries.size() );
28692 detail::ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
28693 for ( auto const & pipelineBinary : pipelineBinaries )
28694 {
28695 uniquePipelineBinaries.push_back( UniqueHandle<PipelineBinaryKHR, Dispatch>( pipelineBinary, deleter ) );
28696 }
28697 return ResultValue<std::vector<UniqueHandle<PipelineBinaryKHR, Dispatch>, PipelineBinaryKHRAllocator>>( result, std::move( uniquePipelineBinaries ) );
28698 }
28699 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
28700 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
28701
28702 // wrapper function for command vkDestroyPipelineBinaryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineBinaryKHR.html
28703 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
28704 VULKAN_HPP_INLINE void
28705 Device::destroyPipelineBinaryKHR( PipelineBinaryKHR pipelineBinary, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
28706 {
28707 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
28708 d.vkDestroyPipelineBinaryKHR(
28709 static_cast<VkDevice>( m_device ), static_cast<VkPipelineBinaryKHR>( pipelineBinary ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
28710 }
28711
28712 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
28713 // wrapper function for command vkDestroyPipelineBinaryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineBinaryKHR.html
28714 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
28715 VULKAN_HPP_INLINE void Device::destroyPipelineBinaryKHR( PipelineBinaryKHR pipelineBinary,
28716 Optional<const AllocationCallbacks> allocator,
28717 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
28718 {
28719 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
28720 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
28721 VULKAN_HPP_ASSERT( d.vkDestroyPipelineBinaryKHR && "Function <vkDestroyPipelineBinaryKHR> requires <VK_KHR_pipeline_binary>" );
28722 # endif
28723
28724 d.vkDestroyPipelineBinaryKHR(
28725 m_device, static_cast<VkPipelineBinaryKHR>( pipelineBinary ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
28726 }
28727 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
28728
28729 // wrapper function for command vkDestroyPipelineBinaryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineBinaryKHR.html
28730 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
28731 VULKAN_HPP_INLINE void
28732 Device::destroy( PipelineBinaryKHR pipelineBinary, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
28733 {
28734 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
28735 d.vkDestroyPipelineBinaryKHR(
28736 static_cast<VkDevice>( m_device ), static_cast<VkPipelineBinaryKHR>( pipelineBinary ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
28737 }
28738
28739 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
28740 // wrapper function for command vkDestroyPipelineBinaryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineBinaryKHR.html
28741 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
28742 VULKAN_HPP_INLINE void
28743 Device::destroy( PipelineBinaryKHR pipelineBinary, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
28744 {
28745 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
28746 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
28747 VULKAN_HPP_ASSERT( d.vkDestroyPipelineBinaryKHR && "Function <vkDestroyPipelineBinaryKHR> requires <VK_KHR_pipeline_binary>" );
28748 # endif
28749
28750 d.vkDestroyPipelineBinaryKHR(
28751 m_device, static_cast<VkPipelineBinaryKHR>( pipelineBinary ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
28752 }
28753 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
28754
28755 // wrapper function for command vkGetPipelineKeyKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineKeyKHR.html
28756 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
28757 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getPipelineKeyKHR( const PipelineCreateInfoKHR * pPipelineCreateInfo,
28758 PipelineBinaryKeyKHR * pPipelineKey,
28759 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
28760 {
28761 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
28762 return static_cast<Result>( d.vkGetPipelineKeyKHR( static_cast<VkDevice>( m_device ),
28763 reinterpret_cast<const VkPipelineCreateInfoKHR *>( pPipelineCreateInfo ),
28764 reinterpret_cast<VkPipelineBinaryKeyKHR *>( pPipelineKey ) ) );
28765 }
28766
28767 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
28768 // wrapper function for command vkGetPipelineKeyKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineKeyKHR.html
28769 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
28770 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<PipelineBinaryKeyKHR>::type
28771 Device::getPipelineKeyKHR( Optional<const PipelineCreateInfoKHR> pipelineCreateInfo, Dispatch const & d ) const
28772 {
28773 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
28774 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
28775 VULKAN_HPP_ASSERT( d.vkGetPipelineKeyKHR && "Function <vkGetPipelineKeyKHR> requires <VK_KHR_pipeline_binary>" );
28776 # endif
28777
28778 PipelineBinaryKeyKHR pipelineKey;
28779 Result result = static_cast<Result>( d.vkGetPipelineKeyKHR(
28780 m_device, reinterpret_cast<const VkPipelineCreateInfoKHR *>( pipelineCreateInfo.get() ), reinterpret_cast<VkPipelineBinaryKeyKHR *>( &pipelineKey ) ) );
28781 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineKeyKHR" );
28782
28783 return detail::createResultValueType( result, std::move( pipelineKey ) );
28784 }
28785 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
28786
28787 // wrapper function for command vkGetPipelineBinaryDataKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineBinaryDataKHR.html
28788 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
28789 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getPipelineBinaryDataKHR( const PipelineBinaryDataInfoKHR * pInfo,
28790 PipelineBinaryKeyKHR * pPipelineBinaryKey,
28791 size_t * pPipelineBinaryDataSize,
28792 void * pPipelineBinaryData,
28793 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
28794 {
28795 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
28796 return static_cast<Result>( d.vkGetPipelineBinaryDataKHR( static_cast<VkDevice>( m_device ),
28797 reinterpret_cast<const VkPipelineBinaryDataInfoKHR *>( pInfo ),
28798 reinterpret_cast<VkPipelineBinaryKeyKHR *>( pPipelineBinaryKey ),
28799 pPipelineBinaryDataSize,
28800 pPipelineBinaryData ) );
28801 }
28802
28803 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
28804 // wrapper function for command vkGetPipelineBinaryDataKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineBinaryDataKHR.html
28805 template <typename Uint8_tAllocator,
28806 typename Dispatch,
28807 typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type,
28808 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
28809 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::pair<PipelineBinaryKeyKHR, std::vector<uint8_t, Uint8_tAllocator>>>::type
28810 Device::getPipelineBinaryDataKHR( const PipelineBinaryDataInfoKHR & info, Dispatch const & d ) const
28811 {
28812 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
28813 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
28814 VULKAN_HPP_ASSERT( d.vkGetPipelineBinaryDataKHR && "Function <vkGetPipelineBinaryDataKHR> requires <VK_KHR_pipeline_binary>" );
28815 # endif
28816
28817 std::pair<PipelineBinaryKeyKHR, std::vector<uint8_t, Uint8_tAllocator>> data_;
28818 PipelineBinaryKeyKHR & pipelineBinaryKey = data_.first;
28819 std::vector<uint8_t, Uint8_tAllocator> & pipelineBinaryData = data_.second;
28820 size_t pipelineBinaryDataSize;
28821 Result result = static_cast<Result>( d.vkGetPipelineBinaryDataKHR( m_device,
28822 reinterpret_cast<const VkPipelineBinaryDataInfoKHR *>( &info ),
28823 reinterpret_cast<VkPipelineBinaryKeyKHR *>( &pipelineBinaryKey ),
28824 &pipelineBinaryDataSize,
28825 nullptr ) );
28826 if ( result == Result::eSuccess )
28827 {
28828 pipelineBinaryData.resize( pipelineBinaryDataSize );
28829 result = static_cast<Result>( d.vkGetPipelineBinaryDataKHR( m_device,
28830 reinterpret_cast<const VkPipelineBinaryDataInfoKHR *>( &info ),
28831 reinterpret_cast<VkPipelineBinaryKeyKHR *>( &pipelineBinaryKey ),
28832 &pipelineBinaryDataSize,
28833 reinterpret_cast<void *>( pipelineBinaryData.data() ) ) );
28834 }
28835
28836 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineBinaryDataKHR" );
28837
28838 return detail::createResultValueType( result, std::move( data_ ) );
28839 }
28840
28841 // wrapper function for command vkGetPipelineBinaryDataKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineBinaryDataKHR.html
28842 template <typename Uint8_tAllocator,
28843 typename Dispatch,
28844 typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type,
28845 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
28846 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::pair<PipelineBinaryKeyKHR, std::vector<uint8_t, Uint8_tAllocator>>>::type
28847 Device::getPipelineBinaryDataKHR( const PipelineBinaryDataInfoKHR & info, Uint8_tAllocator & uint8_tAllocator, Dispatch const & d ) const
28848 {
28849 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
28850 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
28851 VULKAN_HPP_ASSERT( d.vkGetPipelineBinaryDataKHR && "Function <vkGetPipelineBinaryDataKHR> requires <VK_KHR_pipeline_binary>" );
28852 # endif
28853
28854 std::pair<PipelineBinaryKeyKHR, std::vector<uint8_t, Uint8_tAllocator>> data_(
28855 std::piecewise_construct, std::forward_as_tuple(), std::forward_as_tuple( uint8_tAllocator ) );
28856 PipelineBinaryKeyKHR & pipelineBinaryKey = data_.first;
28857 std::vector<uint8_t, Uint8_tAllocator> & pipelineBinaryData = data_.second;
28858 size_t pipelineBinaryDataSize;
28859 Result result = static_cast<Result>( d.vkGetPipelineBinaryDataKHR( m_device,
28860 reinterpret_cast<const VkPipelineBinaryDataInfoKHR *>( &info ),
28861 reinterpret_cast<VkPipelineBinaryKeyKHR *>( &pipelineBinaryKey ),
28862 &pipelineBinaryDataSize,
28863 nullptr ) );
28864 if ( result == Result::eSuccess )
28865 {
28866 pipelineBinaryData.resize( pipelineBinaryDataSize );
28867 result = static_cast<Result>( d.vkGetPipelineBinaryDataKHR( m_device,
28868 reinterpret_cast<const VkPipelineBinaryDataInfoKHR *>( &info ),
28869 reinterpret_cast<VkPipelineBinaryKeyKHR *>( &pipelineBinaryKey ),
28870 &pipelineBinaryDataSize,
28871 reinterpret_cast<void *>( pipelineBinaryData.data() ) ) );
28872 }
28873
28874 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineBinaryDataKHR" );
28875
28876 return detail::createResultValueType( result, std::move( data_ ) );
28877 }
28878 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
28879
28880 // wrapper function for command vkReleaseCapturedPipelineDataKHR, see
28881 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseCapturedPipelineDataKHR.html
28882 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
28883 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::releaseCapturedPipelineDataKHR( const ReleaseCapturedPipelineDataInfoKHR * pInfo,
28884 const AllocationCallbacks * pAllocator,
28885 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
28886 {
28887 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
28888 return static_cast<Result>( d.vkReleaseCapturedPipelineDataKHR( static_cast<VkDevice>( m_device ),
28889 reinterpret_cast<const VkReleaseCapturedPipelineDataInfoKHR *>( pInfo ),
28890 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ) );
28891 }
28892
28893 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
28894 // wrapper function for command vkReleaseCapturedPipelineDataKHR, see
28895 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseCapturedPipelineDataKHR.html
28896 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
28897 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::releaseCapturedPipelineDataKHR(
28898 const ReleaseCapturedPipelineDataInfoKHR & info, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
28899 {
28900 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
28901 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
28902 VULKAN_HPP_ASSERT( d.vkReleaseCapturedPipelineDataKHR && "Function <vkReleaseCapturedPipelineDataKHR> requires <VK_KHR_pipeline_binary>" );
28903 # endif
28904
28905 Result result = static_cast<Result>( d.vkReleaseCapturedPipelineDataKHR(
28906 m_device, reinterpret_cast<const VkReleaseCapturedPipelineDataInfoKHR *>( &info ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) ) );
28907 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::releaseCapturedPipelineDataKHR" );
28908
28909 return detail::createResultValueType( result );
28910 }
28911 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
28912
28913 //=== VK_QCOM_tile_properties ===
28914
28915 // wrapper function for command vkGetFramebufferTilePropertiesQCOM, see
28916 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFramebufferTilePropertiesQCOM.html
28917 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
28918 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getFramebufferTilePropertiesQCOM( Framebuffer framebuffer,
28919 uint32_t * pPropertiesCount,
28920 TilePropertiesQCOM * pProperties,
28921 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
28922 {
28923 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
28924 return static_cast<Result>( d.vkGetFramebufferTilePropertiesQCOM( static_cast<VkDevice>( m_device ),
28925 static_cast<VkFramebuffer>( framebuffer ),
28926 pPropertiesCount,
28927 reinterpret_cast<VkTilePropertiesQCOM *>( pProperties ) ) );
28928 }
28929
28930 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
28931 // wrapper function for command vkGetFramebufferTilePropertiesQCOM, see
28932 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFramebufferTilePropertiesQCOM.html
28933 template <typename TilePropertiesQCOMAllocator,
28934 typename Dispatch,
28935 typename std::enable_if<std::is_same<typename TilePropertiesQCOMAllocator::value_type, TilePropertiesQCOM>::value, int>::type,
28936 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
28937 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<TilePropertiesQCOM, TilePropertiesQCOMAllocator>>::type
28938 Device::getFramebufferTilePropertiesQCOM( Framebuffer framebuffer, Dispatch const & d ) const
28939 {
28940 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
28941 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
28942 VULKAN_HPP_ASSERT( d.vkGetFramebufferTilePropertiesQCOM && "Function <vkGetFramebufferTilePropertiesQCOM> requires <VK_QCOM_tile_properties>" );
28943 # endif
28944
28945 std::vector<TilePropertiesQCOM, TilePropertiesQCOMAllocator> properties;
28946 uint32_t propertiesCount;
28947 Result result;
28948 do
28949 {
28950 result = static_cast<Result>( d.vkGetFramebufferTilePropertiesQCOM( m_device, static_cast<VkFramebuffer>( framebuffer ), &propertiesCount, nullptr ) );
28951 if ( ( result == Result::eSuccess ) && propertiesCount )
28952 {
28953 properties.resize( propertiesCount );
28954 result = static_cast<Result>( d.vkGetFramebufferTilePropertiesQCOM(
28955 m_device, static_cast<VkFramebuffer>( framebuffer ), &propertiesCount, reinterpret_cast<VkTilePropertiesQCOM *>( properties.data() ) ) );
28956 }
28957 } while ( result == Result::eIncomplete );
28958 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getFramebufferTilePropertiesQCOM" );
28959 VULKAN_HPP_ASSERT( propertiesCount <= properties.size() );
28960 if ( propertiesCount < properties.size() )
28961 {
28962 properties.resize( propertiesCount );
28963 }
28964 return detail::createResultValueType( result, std::move( properties ) );
28965 }
28966
28967 // wrapper function for command vkGetFramebufferTilePropertiesQCOM, see
28968 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFramebufferTilePropertiesQCOM.html
28969 template <typename TilePropertiesQCOMAllocator,
28970 typename Dispatch,
28971 typename std::enable_if<std::is_same<typename TilePropertiesQCOMAllocator::value_type, TilePropertiesQCOM>::value, int>::type,
28972 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
28973 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<TilePropertiesQCOM, TilePropertiesQCOMAllocator>>::type
28974 Device::getFramebufferTilePropertiesQCOM( Framebuffer framebuffer, TilePropertiesQCOMAllocator & tilePropertiesQCOMAllocator, Dispatch const & d ) const
28975 {
28976 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
28977 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
28978 VULKAN_HPP_ASSERT( d.vkGetFramebufferTilePropertiesQCOM && "Function <vkGetFramebufferTilePropertiesQCOM> requires <VK_QCOM_tile_properties>" );
28979 # endif
28980
28981 std::vector<TilePropertiesQCOM, TilePropertiesQCOMAllocator> properties( tilePropertiesQCOMAllocator );
28982 uint32_t propertiesCount;
28983 Result result;
28984 do
28985 {
28986 result = static_cast<Result>( d.vkGetFramebufferTilePropertiesQCOM( m_device, static_cast<VkFramebuffer>( framebuffer ), &propertiesCount, nullptr ) );
28987 if ( ( result == Result::eSuccess ) && propertiesCount )
28988 {
28989 properties.resize( propertiesCount );
28990 result = static_cast<Result>( d.vkGetFramebufferTilePropertiesQCOM(
28991 m_device, static_cast<VkFramebuffer>( framebuffer ), &propertiesCount, reinterpret_cast<VkTilePropertiesQCOM *>( properties.data() ) ) );
28992 }
28993 } while ( result == Result::eIncomplete );
28994 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getFramebufferTilePropertiesQCOM" );
28995 VULKAN_HPP_ASSERT( propertiesCount <= properties.size() );
28996 if ( propertiesCount < properties.size() )
28997 {
28998 properties.resize( propertiesCount );
28999 }
29000 return detail::createResultValueType( result, std::move( properties ) );
29001 }
29002 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
29003
29004 // wrapper function for command vkGetDynamicRenderingTilePropertiesQCOM, see
29005 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDynamicRenderingTilePropertiesQCOM.html
29006 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
29007 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getDynamicRenderingTilePropertiesQCOM( const RenderingInfo * pRenderingInfo,
29008 TilePropertiesQCOM * pProperties,
29009 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
29010 {
29011 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
29012 return static_cast<Result>( d.vkGetDynamicRenderingTilePropertiesQCOM( static_cast<VkDevice>( m_device ),
29013 reinterpret_cast<const VkRenderingInfo *>( pRenderingInfo ),
29014 reinterpret_cast<VkTilePropertiesQCOM *>( pProperties ) ) );
29015 }
29016
29017 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
29018 // wrapper function for command vkGetDynamicRenderingTilePropertiesQCOM, see
29019 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDynamicRenderingTilePropertiesQCOM.html
29020 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
29021 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<TilePropertiesQCOM>::type
29022 Device::getDynamicRenderingTilePropertiesQCOM( const RenderingInfo & renderingInfo, Dispatch const & d ) const
29023 {
29024 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
29025 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
29026 VULKAN_HPP_ASSERT( d.vkGetDynamicRenderingTilePropertiesQCOM && "Function <vkGetDynamicRenderingTilePropertiesQCOM> requires <VK_QCOM_tile_properties>" );
29027 # endif
29028
29029 TilePropertiesQCOM properties;
29030 Result result = static_cast<Result>( d.vkGetDynamicRenderingTilePropertiesQCOM(
29031 m_device, reinterpret_cast<const VkRenderingInfo *>( &renderingInfo ), reinterpret_cast<VkTilePropertiesQCOM *>( &properties ) ) );
29032 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getDynamicRenderingTilePropertiesQCOM" );
29033
29034 return detail::createResultValueType( result, std::move( properties ) );
29035 }
29036 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
29037
29038 //=== VK_KHR_swapchain_maintenance1 ===
29039
29040 // wrapper function for command vkReleaseSwapchainImagesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseSwapchainImagesKHR.html
29041 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
29042 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::releaseSwapchainImagesKHR( const ReleaseSwapchainImagesInfoKHR * pReleaseInfo,
29043 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
29044 {
29045 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
29046 return static_cast<Result>(
29047 d.vkReleaseSwapchainImagesKHR( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkReleaseSwapchainImagesInfoKHR *>( pReleaseInfo ) ) );
29048 }
29049
29050 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
29051 // wrapper function for command vkReleaseSwapchainImagesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseSwapchainImagesKHR.html
29052 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
29053 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
29054 Device::releaseSwapchainImagesKHR( const ReleaseSwapchainImagesInfoKHR & releaseInfo, Dispatch const & d ) const
29055 {
29056 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
29057 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
29058 VULKAN_HPP_ASSERT( d.vkReleaseSwapchainImagesKHR &&
29059 "Function <vkReleaseSwapchainImagesKHR> requires <VK_EXT_swapchain_maintenance1> or <VK_KHR_swapchain_maintenance1>" );
29060 # endif
29061
29062 Result result = static_cast<Result>( d.vkReleaseSwapchainImagesKHR( m_device, reinterpret_cast<const VkReleaseSwapchainImagesInfoKHR *>( &releaseInfo ) ) );
29063 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::releaseSwapchainImagesKHR" );
29064
29065 return detail::createResultValueType( result );
29066 }
29067 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
29068
29069 //=== VK_NV_cooperative_vector ===
29070
29071 // wrapper function for command vkGetPhysicalDeviceCooperativeVectorPropertiesNV, see
29072 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeVectorPropertiesNV.html
29073 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
29074 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getCooperativeVectorPropertiesNV( uint32_t * pPropertyCount,
29075 CooperativeVectorPropertiesNV * pProperties,
29076 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
29077 {
29078 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
29079 return static_cast<Result>( d.vkGetPhysicalDeviceCooperativeVectorPropertiesNV(
29080 static_cast<VkPhysicalDevice>( m_physicalDevice ), pPropertyCount, reinterpret_cast<VkCooperativeVectorPropertiesNV *>( pProperties ) ) );
29081 }
29082
29083 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
29084 // wrapper function for command vkGetPhysicalDeviceCooperativeVectorPropertiesNV, see
29085 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeVectorPropertiesNV.html
29086 template <typename CooperativeVectorPropertiesNVAllocator,
29087 typename Dispatch,
29088 typename std::enable_if<std::is_same<typename CooperativeVectorPropertiesNVAllocator::value_type, CooperativeVectorPropertiesNV>::value, int>::type,
29089 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
29090 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<CooperativeVectorPropertiesNV, CooperativeVectorPropertiesNVAllocator>>::type
29091 PhysicalDevice::getCooperativeVectorPropertiesNV( Dispatch const & d ) const
29092 {
29093 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
29094 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
29095 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceCooperativeVectorPropertiesNV &&
29096 "Function <vkGetPhysicalDeviceCooperativeVectorPropertiesNV> requires <VK_NV_cooperative_vector>" );
29097 # endif
29098
29099 std::vector<CooperativeVectorPropertiesNV, CooperativeVectorPropertiesNVAllocator> properties;
29100 uint32_t propertyCount;
29101 Result result;
29102 do
29103 {
29104 result = static_cast<Result>( d.vkGetPhysicalDeviceCooperativeVectorPropertiesNV( m_physicalDevice, &propertyCount, nullptr ) );
29105 if ( ( result == Result::eSuccess ) && propertyCount )
29106 {
29107 properties.resize( propertyCount );
29108 result = static_cast<Result>( d.vkGetPhysicalDeviceCooperativeVectorPropertiesNV(
29109 m_physicalDevice, &propertyCount, reinterpret_cast<VkCooperativeVectorPropertiesNV *>( properties.data() ) ) );
29110 }
29111 } while ( result == Result::eIncomplete );
29112 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCooperativeVectorPropertiesNV" );
29113 VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
29114 if ( propertyCount < properties.size() )
29115 {
29116 properties.resize( propertyCount );
29117 }
29118 return detail::createResultValueType( result, std::move( properties ) );
29119 }
29120
29121 // wrapper function for command vkGetPhysicalDeviceCooperativeVectorPropertiesNV, see
29122 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeVectorPropertiesNV.html
29123 template <typename CooperativeVectorPropertiesNVAllocator,
29124 typename Dispatch,
29125 typename std::enable_if<std::is_same<typename CooperativeVectorPropertiesNVAllocator::value_type, CooperativeVectorPropertiesNV>::value, int>::type,
29126 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
29127 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<CooperativeVectorPropertiesNV, CooperativeVectorPropertiesNVAllocator>>::type
29128 PhysicalDevice::getCooperativeVectorPropertiesNV( CooperativeVectorPropertiesNVAllocator & cooperativeVectorPropertiesNVAllocator,
29129 Dispatch const & d ) const
29130 {
29131 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
29132 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
29133 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceCooperativeVectorPropertiesNV &&
29134 "Function <vkGetPhysicalDeviceCooperativeVectorPropertiesNV> requires <VK_NV_cooperative_vector>" );
29135 # endif
29136
29137 std::vector<CooperativeVectorPropertiesNV, CooperativeVectorPropertiesNVAllocator> properties( cooperativeVectorPropertiesNVAllocator );
29138 uint32_t propertyCount;
29139 Result result;
29140 do
29141 {
29142 result = static_cast<Result>( d.vkGetPhysicalDeviceCooperativeVectorPropertiesNV( m_physicalDevice, &propertyCount, nullptr ) );
29143 if ( ( result == Result::eSuccess ) && propertyCount )
29144 {
29145 properties.resize( propertyCount );
29146 result = static_cast<Result>( d.vkGetPhysicalDeviceCooperativeVectorPropertiesNV(
29147 m_physicalDevice, &propertyCount, reinterpret_cast<VkCooperativeVectorPropertiesNV *>( properties.data() ) ) );
29148 }
29149 } while ( result == Result::eIncomplete );
29150 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCooperativeVectorPropertiesNV" );
29151 VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
29152 if ( propertyCount < properties.size() )
29153 {
29154 properties.resize( propertyCount );
29155 }
29156 return detail::createResultValueType( result, std::move( properties ) );
29157 }
29158 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
29159
29160 // wrapper function for command vkConvertCooperativeVectorMatrixNV, see
29161 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkConvertCooperativeVectorMatrixNV.html
29162 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
29163 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::convertCooperativeVectorMatrixNV( const ConvertCooperativeVectorMatrixInfoNV * pInfo,
29164 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
29165 {
29166 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
29167 return static_cast<Result>(
29168 d.vkConvertCooperativeVectorMatrixNV( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkConvertCooperativeVectorMatrixInfoNV *>( pInfo ) ) );
29169 }
29170
29171 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
29172 // wrapper function for command vkConvertCooperativeVectorMatrixNV, see
29173 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkConvertCooperativeVectorMatrixNV.html
29174 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
29175 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::convertCooperativeVectorMatrixNV( const ConvertCooperativeVectorMatrixInfoNV & info,
29176 Dispatch const & d ) const
29177 {
29178 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
29179 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
29180 VULKAN_HPP_ASSERT( d.vkConvertCooperativeVectorMatrixNV && "Function <vkConvertCooperativeVectorMatrixNV> requires <VK_NV_cooperative_vector>" );
29181 # endif
29182
29183 Result result =
29184 static_cast<Result>( d.vkConvertCooperativeVectorMatrixNV( m_device, reinterpret_cast<const VkConvertCooperativeVectorMatrixInfoNV *>( &info ) ) );
29185 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::convertCooperativeVectorMatrixNV", { Result::eSuccess, Result::eIncomplete } );
29186
29187 return static_cast<Result>( result );
29188 }
29189 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
29190
29191 // wrapper function for command vkCmdConvertCooperativeVectorMatrixNV, see
29192 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdConvertCooperativeVectorMatrixNV.html
29193 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
29194 VULKAN_HPP_INLINE void CommandBuffer::convertCooperativeVectorMatrixNV( uint32_t infoCount,
29195 const ConvertCooperativeVectorMatrixInfoNV * pInfos,
29196 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
29197 {
29198 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
29199 d.vkCmdConvertCooperativeVectorMatrixNV(
29200 static_cast<VkCommandBuffer>( m_commandBuffer ), infoCount, reinterpret_cast<const VkConvertCooperativeVectorMatrixInfoNV *>( pInfos ) );
29201 }
29202
29203 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
29204 // wrapper function for command vkCmdConvertCooperativeVectorMatrixNV, see
29205 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdConvertCooperativeVectorMatrixNV.html
29206 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
29207 VULKAN_HPP_INLINE void CommandBuffer::convertCooperativeVectorMatrixNV( ArrayProxy<const ConvertCooperativeVectorMatrixInfoNV> const & infos,
29208 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
29209 {
29210 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
29211 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
29212 VULKAN_HPP_ASSERT( d.vkCmdConvertCooperativeVectorMatrixNV && "Function <vkCmdConvertCooperativeVectorMatrixNV> requires <VK_NV_cooperative_vector>" );
29213 # endif
29214
29215 d.vkCmdConvertCooperativeVectorMatrixNV( m_commandBuffer, infos.size(), reinterpret_cast<const VkConvertCooperativeVectorMatrixInfoNV *>( infos.data() ) );
29216 }
29217 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
29218
29219 //=== VK_NV_low_latency2 ===
29220
29221 // wrapper function for command vkSetLatencySleepModeNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetLatencySleepModeNV.html
29222 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
29223 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::setLatencySleepModeNV( SwapchainKHR swapchain,
29224 const LatencySleepModeInfoNV * pSleepModeInfo,
29225 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
29226 {
29227 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
29228 return static_cast<Result>( d.vkSetLatencySleepModeNV(
29229 static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<const VkLatencySleepModeInfoNV *>( pSleepModeInfo ) ) );
29230 }
29231
29232 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
29233 // wrapper function for command vkSetLatencySleepModeNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetLatencySleepModeNV.html
29234 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
29235 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
29236 Device::setLatencySleepModeNV( SwapchainKHR swapchain, const LatencySleepModeInfoNV & sleepModeInfo, Dispatch const & d ) const
29237 {
29238 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
29239 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
29240 VULKAN_HPP_ASSERT( d.vkSetLatencySleepModeNV && "Function <vkSetLatencySleepModeNV> requires <VK_NV_low_latency2>" );
29241 # endif
29242
29243 Result result = static_cast<Result>(
29244 d.vkSetLatencySleepModeNV( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<const VkLatencySleepModeInfoNV *>( &sleepModeInfo ) ) );
29245 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setLatencySleepModeNV" );
29246
29247 return detail::createResultValueType( result );
29248 }
29249 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
29250
29251 // wrapper function for command vkLatencySleepNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkLatencySleepNV.html
29252 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
29253 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::latencySleepNV( SwapchainKHR swapchain,
29254 const LatencySleepInfoNV * pSleepInfo,
29255 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
29256 {
29257 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
29258 return static_cast<Result>( d.vkLatencySleepNV(
29259 static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<const VkLatencySleepInfoNV *>( pSleepInfo ) ) );
29260 }
29261
29262 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
29263 // wrapper function for command vkLatencySleepNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkLatencySleepNV.html
29264 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
29265 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
29266 Device::latencySleepNV( SwapchainKHR swapchain, const LatencySleepInfoNV & sleepInfo, Dispatch const & d ) const
29267 {
29268 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
29269 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
29270 VULKAN_HPP_ASSERT( d.vkLatencySleepNV && "Function <vkLatencySleepNV> requires <VK_NV_low_latency2>" );
29271 # endif
29272
29273 Result result = static_cast<Result>(
29274 d.vkLatencySleepNV( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<const VkLatencySleepInfoNV *>( &sleepInfo ) ) );
29275 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::latencySleepNV" );
29276
29277 return detail::createResultValueType( result );
29278 }
29279 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
29280
29281 // wrapper function for command vkSetLatencyMarkerNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetLatencyMarkerNV.html
29282 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
29283 VULKAN_HPP_INLINE void
29284 Device::setLatencyMarkerNV( SwapchainKHR swapchain, const SetLatencyMarkerInfoNV * pLatencyMarkerInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
29285 {
29286 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
29287 d.vkSetLatencyMarkerNV(
29288 static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<const VkSetLatencyMarkerInfoNV *>( pLatencyMarkerInfo ) );
29289 }
29290
29291 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
29292 // wrapper function for command vkSetLatencyMarkerNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetLatencyMarkerNV.html
29293 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
29294 VULKAN_HPP_INLINE void
29295 Device::setLatencyMarkerNV( SwapchainKHR swapchain, const SetLatencyMarkerInfoNV & latencyMarkerInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
29296 {
29297 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
29298 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
29299 VULKAN_HPP_ASSERT( d.vkSetLatencyMarkerNV && "Function <vkSetLatencyMarkerNV> requires <VK_NV_low_latency2>" );
29300 # endif
29301
29302 d.vkSetLatencyMarkerNV( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<const VkSetLatencyMarkerInfoNV *>( &latencyMarkerInfo ) );
29303 }
29304 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
29305
29306 // wrapper function for command vkGetLatencyTimingsNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetLatencyTimingsNV.html
29307 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
29308 VULKAN_HPP_INLINE void
29309 Device::getLatencyTimingsNV( SwapchainKHR swapchain, GetLatencyMarkerInfoNV * pLatencyMarkerInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
29310 {
29311 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
29312 d.vkGetLatencyTimingsNV(
29313 static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<VkGetLatencyMarkerInfoNV *>( pLatencyMarkerInfo ) );
29314 }
29315
29316 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
29317 // wrapper function for command vkGetLatencyTimingsNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetLatencyTimingsNV.html
29318 template <typename LatencyTimingsFrameReportNVAllocator,
29319 typename Dispatch,
29320 typename std::enable_if<std::is_same<typename LatencyTimingsFrameReportNVAllocator::value_type, LatencyTimingsFrameReportNV>::value, int>::type,
29321 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
29322 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<LatencyTimingsFrameReportNV, LatencyTimingsFrameReportNVAllocator>
29323 Device::getLatencyTimingsNV( SwapchainKHR swapchain, Dispatch const & d ) const
29324 {
29325 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
29326 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
29327 VULKAN_HPP_ASSERT( d.vkGetLatencyTimingsNV && "Function <vkGetLatencyTimingsNV> requires <VK_NV_low_latency2>" );
29328 # endif
29329
29330 std::vector<LatencyTimingsFrameReportNV, LatencyTimingsFrameReportNVAllocator> timings;
29331 GetLatencyMarkerInfoNV latencyMarkerInfo;
29332 d.vkGetLatencyTimingsNV( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<VkGetLatencyMarkerInfoNV *>( &latencyMarkerInfo ) );
29333 timings.resize( latencyMarkerInfo.timingCount );
29334 latencyMarkerInfo.pTimings = timings.data();
29335 d.vkGetLatencyTimingsNV( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<VkGetLatencyMarkerInfoNV *>( &latencyMarkerInfo ) );
29336
29337 return timings;
29338 }
29339
29340 // wrapper function for command vkGetLatencyTimingsNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetLatencyTimingsNV.html
29341 template <typename LatencyTimingsFrameReportNVAllocator,
29342 typename Dispatch,
29343 typename std::enable_if<std::is_same<typename LatencyTimingsFrameReportNVAllocator::value_type, LatencyTimingsFrameReportNV>::value, int>::type,
29344 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
29345 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<LatencyTimingsFrameReportNV, LatencyTimingsFrameReportNVAllocator>
29346 Device::getLatencyTimingsNV( SwapchainKHR swapchain, LatencyTimingsFrameReportNVAllocator & latencyTimingsFrameReportNVAllocator, Dispatch const & d ) const
29347 {
29348 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
29349 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
29350 VULKAN_HPP_ASSERT( d.vkGetLatencyTimingsNV && "Function <vkGetLatencyTimingsNV> requires <VK_NV_low_latency2>" );
29351 # endif
29352
29353 std::vector<LatencyTimingsFrameReportNV, LatencyTimingsFrameReportNVAllocator> timings( latencyTimingsFrameReportNVAllocator );
29354 GetLatencyMarkerInfoNV latencyMarkerInfo;
29355 d.vkGetLatencyTimingsNV( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<VkGetLatencyMarkerInfoNV *>( &latencyMarkerInfo ) );
29356 timings.resize( latencyMarkerInfo.timingCount );
29357 latencyMarkerInfo.pTimings = timings.data();
29358 d.vkGetLatencyTimingsNV( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<VkGetLatencyMarkerInfoNV *>( &latencyMarkerInfo ) );
29359
29360 return timings;
29361 }
29362 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
29363
29364 // wrapper function for command vkQueueNotifyOutOfBandNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueNotifyOutOfBandNV.html
29365 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
29366 VULKAN_HPP_INLINE void Queue::notifyOutOfBandNV( const OutOfBandQueueTypeInfoNV * pQueueTypeInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
29367 {
29368 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
29369 d.vkQueueNotifyOutOfBandNV( static_cast<VkQueue>( m_queue ), reinterpret_cast<const VkOutOfBandQueueTypeInfoNV *>( pQueueTypeInfo ) );
29370 }
29371
29372 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
29373 // wrapper function for command vkQueueNotifyOutOfBandNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueNotifyOutOfBandNV.html
29374 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
29375 VULKAN_HPP_INLINE void Queue::notifyOutOfBandNV( const OutOfBandQueueTypeInfoNV & queueTypeInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
29376 {
29377 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
29378 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
29379 VULKAN_HPP_ASSERT( d.vkQueueNotifyOutOfBandNV && "Function <vkQueueNotifyOutOfBandNV> requires <VK_NV_low_latency2>" );
29380 # endif
29381
29382 d.vkQueueNotifyOutOfBandNV( m_queue, reinterpret_cast<const VkOutOfBandQueueTypeInfoNV *>( &queueTypeInfo ) );
29383 }
29384 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
29385
29386 //=== VK_KHR_cooperative_matrix ===
29387
29388 // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR, see
29389 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR.html
29390 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
29391 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getCooperativeMatrixPropertiesKHR( uint32_t * pPropertyCount,
29392 CooperativeMatrixPropertiesKHR * pProperties,
29393 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
29394 {
29395 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
29396 return static_cast<Result>( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(
29397 static_cast<VkPhysicalDevice>( m_physicalDevice ), pPropertyCount, reinterpret_cast<VkCooperativeMatrixPropertiesKHR *>( pProperties ) ) );
29398 }
29399
29400 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
29401 // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR, see
29402 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR.html
29403 template <
29404 typename CooperativeMatrixPropertiesKHRAllocator,
29405 typename Dispatch,
29406 typename std::enable_if<std::is_same<typename CooperativeMatrixPropertiesKHRAllocator::value_type, CooperativeMatrixPropertiesKHR>::value, int>::type,
29407 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
29408 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<CooperativeMatrixPropertiesKHR, CooperativeMatrixPropertiesKHRAllocator>>::type
29409 PhysicalDevice::getCooperativeMatrixPropertiesKHR( Dispatch const & d ) const
29410 {
29411 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
29412 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
29413 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR &&
29414 "Function <vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR> requires <VK_KHR_cooperative_matrix>" );
29415 # endif
29416
29417 std::vector<CooperativeMatrixPropertiesKHR, CooperativeMatrixPropertiesKHRAllocator> properties;
29418 uint32_t propertyCount;
29419 Result result;
29420 do
29421 {
29422 result = static_cast<Result>( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR( m_physicalDevice, &propertyCount, nullptr ) );
29423 if ( ( result == Result::eSuccess ) && propertyCount )
29424 {
29425 properties.resize( propertyCount );
29426 result = static_cast<Result>( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(
29427 m_physicalDevice, &propertyCount, reinterpret_cast<VkCooperativeMatrixPropertiesKHR *>( properties.data() ) ) );
29428 }
29429 } while ( result == Result::eIncomplete );
29430 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCooperativeMatrixPropertiesKHR" );
29431 VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
29432 if ( propertyCount < properties.size() )
29433 {
29434 properties.resize( propertyCount );
29435 }
29436 return detail::createResultValueType( result, std::move( properties ) );
29437 }
29438
29439 // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR, see
29440 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR.html
29441 template <
29442 typename CooperativeMatrixPropertiesKHRAllocator,
29443 typename Dispatch,
29444 typename std::enable_if<std::is_same<typename CooperativeMatrixPropertiesKHRAllocator::value_type, CooperativeMatrixPropertiesKHR>::value, int>::type,
29445 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
29446 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<CooperativeMatrixPropertiesKHR, CooperativeMatrixPropertiesKHRAllocator>>::type
29447 PhysicalDevice::getCooperativeMatrixPropertiesKHR( CooperativeMatrixPropertiesKHRAllocator & cooperativeMatrixPropertiesKHRAllocator,
29448 Dispatch const & d ) const
29449 {
29450 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
29451 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
29452 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR &&
29453 "Function <vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR> requires <VK_KHR_cooperative_matrix>" );
29454 # endif
29455
29456 std::vector<CooperativeMatrixPropertiesKHR, CooperativeMatrixPropertiesKHRAllocator> properties( cooperativeMatrixPropertiesKHRAllocator );
29457 uint32_t propertyCount;
29458 Result result;
29459 do
29460 {
29461 result = static_cast<Result>( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR( m_physicalDevice, &propertyCount, nullptr ) );
29462 if ( ( result == Result::eSuccess ) && propertyCount )
29463 {
29464 properties.resize( propertyCount );
29465 result = static_cast<Result>( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(
29466 m_physicalDevice, &propertyCount, reinterpret_cast<VkCooperativeMatrixPropertiesKHR *>( properties.data() ) ) );
29467 }
29468 } while ( result == Result::eIncomplete );
29469 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCooperativeMatrixPropertiesKHR" );
29470 VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
29471 if ( propertyCount < properties.size() )
29472 {
29473 properties.resize( propertyCount );
29474 }
29475 return detail::createResultValueType( result, std::move( properties ) );
29476 }
29477 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
29478
29479 //=== VK_ARM_data_graph ===
29480
29481 // wrapper function for command vkCreateDataGraphPipelinesARM, see
29482 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelinesARM.html
29483 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
29484 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createDataGraphPipelinesARM( DeferredOperationKHR deferredOperation,
29485 PipelineCache pipelineCache,
29486 uint32_t createInfoCount,
29487 const DataGraphPipelineCreateInfoARM * pCreateInfos,
29488 const AllocationCallbacks * pAllocator,
29489 Pipeline * pPipelines,
29490 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
29491 {
29492 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
29493 return static_cast<Result>( d.vkCreateDataGraphPipelinesARM( static_cast<VkDevice>( m_device ),
29494 static_cast<VkDeferredOperationKHR>( deferredOperation ),
29495 static_cast<VkPipelineCache>( pipelineCache ),
29496 createInfoCount,
29497 reinterpret_cast<const VkDataGraphPipelineCreateInfoARM *>( pCreateInfos ),
29498 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
29499 reinterpret_cast<VkPipeline *>( pPipelines ) ) );
29500 }
29501
29502 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
29503 // wrapper function for command vkCreateDataGraphPipelinesARM, see
29504 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelinesARM.html
29505 template <typename PipelineAllocator,
29506 typename Dispatch,
29507 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, Pipeline>::value, int>::type,
29508 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
29509 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<Pipeline, PipelineAllocator>>
29510 Device::createDataGraphPipelinesARM( DeferredOperationKHR deferredOperation,
29511 PipelineCache pipelineCache,
29512 ArrayProxy<const DataGraphPipelineCreateInfoARM> const & createInfos,
29513 Optional<const AllocationCallbacks> allocator,
29514 Dispatch const & d ) const
29515 {
29516 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
29517 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
29518 VULKAN_HPP_ASSERT( d.vkCreateDataGraphPipelinesARM && "Function <vkCreateDataGraphPipelinesARM> requires <VK_ARM_data_graph>" );
29519 # endif
29520
29521 std::vector<Pipeline, PipelineAllocator> pipelines( createInfos.size() );
29522 Result result = static_cast<Result>( d.vkCreateDataGraphPipelinesARM( m_device,
29523 static_cast<VkDeferredOperationKHR>( deferredOperation ),
29524 static_cast<VkPipelineCache>( pipelineCache ),
29525 createInfos.size(),
29526 reinterpret_cast<const VkDataGraphPipelineCreateInfoARM *>( createInfos.data() ),
29527 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
29528 reinterpret_cast<VkPipeline *>( pipelines.data() ) ) );
29529 detail::resultCheck(
29530 result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDataGraphPipelinesARM", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } );
29531
29532 return ResultValue<std::vector<Pipeline, PipelineAllocator>>( result, std::move( pipelines ) );
29533 }
29534
29535 // wrapper function for command vkCreateDataGraphPipelinesARM, see
29536 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelinesARM.html
29537 template <typename PipelineAllocator,
29538 typename Dispatch,
29539 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, Pipeline>::value, int>::type,
29540 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
29541 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<Pipeline, PipelineAllocator>>
29542 Device::createDataGraphPipelinesARM( DeferredOperationKHR deferredOperation,
29543 PipelineCache pipelineCache,
29544 ArrayProxy<const DataGraphPipelineCreateInfoARM> const & createInfos,
29545 Optional<const AllocationCallbacks> allocator,
29546 PipelineAllocator & pipelineAllocator,
29547 Dispatch const & d ) const
29548 {
29549 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
29550 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
29551 VULKAN_HPP_ASSERT( d.vkCreateDataGraphPipelinesARM && "Function <vkCreateDataGraphPipelinesARM> requires <VK_ARM_data_graph>" );
29552 # endif
29553
29554 std::vector<Pipeline, PipelineAllocator> pipelines( createInfos.size(), pipelineAllocator );
29555 Result result = static_cast<Result>( d.vkCreateDataGraphPipelinesARM( m_device,
29556 static_cast<VkDeferredOperationKHR>( deferredOperation ),
29557 static_cast<VkPipelineCache>( pipelineCache ),
29558 createInfos.size(),
29559 reinterpret_cast<const VkDataGraphPipelineCreateInfoARM *>( createInfos.data() ),
29560 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
29561 reinterpret_cast<VkPipeline *>( pipelines.data() ) ) );
29562 detail::resultCheck(
29563 result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDataGraphPipelinesARM", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } );
29564
29565 return ResultValue<std::vector<Pipeline, PipelineAllocator>>( result, std::move( pipelines ) );
29566 }
29567
29568 // wrapper function for command vkCreateDataGraphPipelinesARM, see
29569 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelinesARM.html
29570 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
29571 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<Pipeline> Device::createDataGraphPipelineARM( DeferredOperationKHR deferredOperation,
29572 PipelineCache pipelineCache,
29573 const DataGraphPipelineCreateInfoARM & createInfo,
29574 Optional<const AllocationCallbacks> allocator,
29575 Dispatch const & d ) const
29576 {
29577 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
29578 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
29579 VULKAN_HPP_ASSERT( d.vkCreateDataGraphPipelinesARM && "Function <vkCreateDataGraphPipelinesARM> requires <VK_ARM_data_graph>" );
29580 # endif
29581
29582 Pipeline pipeline;
29583 Result result = static_cast<Result>( d.vkCreateDataGraphPipelinesARM( m_device,
29584 static_cast<VkDeferredOperationKHR>( deferredOperation ),
29585 static_cast<VkPipelineCache>( pipelineCache ),
29586 1,
29587 reinterpret_cast<const VkDataGraphPipelineCreateInfoARM *>( &createInfo ),
29588 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
29589 reinterpret_cast<VkPipeline *>( &pipeline ) ) );
29590 detail::resultCheck(
29591 result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDataGraphPipelineARM", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } );
29592
29593 return ResultValue<Pipeline>( result, std::move( pipeline ) );
29594 }
29595
29596 # ifndef VULKAN_HPP_NO_SMART_HANDLE
29597 // wrapper function for command vkCreateDataGraphPipelinesARM, see
29598 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelinesARM.html
29599 template <typename Dispatch,
29600 typename PipelineAllocator,
29601 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<Pipeline, Dispatch>>::value, int>::type,
29602 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
29603 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
29604 Device::createDataGraphPipelinesARMUnique( DeferredOperationKHR deferredOperation,
29605 PipelineCache pipelineCache,
29606 ArrayProxy<const DataGraphPipelineCreateInfoARM> const & createInfos,
29607 Optional<const AllocationCallbacks> allocator,
29608 Dispatch const & d ) const
29609 {
29610 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
29611 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
29612 VULKAN_HPP_ASSERT( d.vkCreateDataGraphPipelinesARM && "Function <vkCreateDataGraphPipelinesARM> requires <VK_ARM_data_graph>" );
29613 # endif
29614
29615 std::vector<Pipeline> pipelines( createInfos.size() );
29616 Result result = static_cast<Result>( d.vkCreateDataGraphPipelinesARM( m_device,
29617 static_cast<VkDeferredOperationKHR>( deferredOperation ),
29618 static_cast<VkPipelineCache>( pipelineCache ),
29619 createInfos.size(),
29620 reinterpret_cast<const VkDataGraphPipelineCreateInfoARM *>( createInfos.data() ),
29621 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
29622 reinterpret_cast<VkPipeline *>( pipelines.data() ) ) );
29623 detail::resultCheck(
29624 result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDataGraphPipelinesARMUnique", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } );
29625 std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator> uniquePipelines;
29626 uniquePipelines.reserve( createInfos.size() );
29627 detail::ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
29628 for ( auto const & pipeline : pipelines )
29629 {
29630 uniquePipelines.push_back( UniqueHandle<Pipeline, Dispatch>( pipeline, deleter ) );
29631 }
29632 return ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>( result, std::move( uniquePipelines ) );
29633 }
29634
29635 // wrapper function for command vkCreateDataGraphPipelinesARM, see
29636 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelinesARM.html
29637 template <typename Dispatch,
29638 typename PipelineAllocator,
29639 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<Pipeline, Dispatch>>::value, int>::type,
29640 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
29641 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
29642 Device::createDataGraphPipelinesARMUnique( DeferredOperationKHR deferredOperation,
29643 PipelineCache pipelineCache,
29644 ArrayProxy<const DataGraphPipelineCreateInfoARM> const & createInfos,
29645 Optional<const AllocationCallbacks> allocator,
29646 PipelineAllocator & pipelineAllocator,
29647 Dispatch const & d ) const
29648 {
29649 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
29650 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
29651 VULKAN_HPP_ASSERT( d.vkCreateDataGraphPipelinesARM && "Function <vkCreateDataGraphPipelinesARM> requires <VK_ARM_data_graph>" );
29652 # endif
29653
29654 std::vector<Pipeline> pipelines( createInfos.size() );
29655 Result result = static_cast<Result>( d.vkCreateDataGraphPipelinesARM( m_device,
29656 static_cast<VkDeferredOperationKHR>( deferredOperation ),
29657 static_cast<VkPipelineCache>( pipelineCache ),
29658 createInfos.size(),
29659 reinterpret_cast<const VkDataGraphPipelineCreateInfoARM *>( createInfos.data() ),
29660 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
29661 reinterpret_cast<VkPipeline *>( pipelines.data() ) ) );
29662 detail::resultCheck(
29663 result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDataGraphPipelinesARMUnique", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } );
29664 std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator> uniquePipelines( pipelineAllocator );
29665 uniquePipelines.reserve( createInfos.size() );
29666 detail::ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
29667 for ( auto const & pipeline : pipelines )
29668 {
29669 uniquePipelines.push_back( UniqueHandle<Pipeline, Dispatch>( pipeline, deleter ) );
29670 }
29671 return ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>( result, std::move( uniquePipelines ) );
29672 }
29673
29674 // wrapper function for command vkCreateDataGraphPipelinesARM, see
29675 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelinesARM.html
29676 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
29677 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<UniqueHandle<Pipeline, Dispatch>>
29678 Device::createDataGraphPipelineARMUnique( DeferredOperationKHR deferredOperation,
29679 PipelineCache pipelineCache,
29680 const DataGraphPipelineCreateInfoARM & createInfo,
29681 Optional<const AllocationCallbacks> allocator,
29682 Dispatch const & d ) const
29683 {
29684 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
29685 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
29686 VULKAN_HPP_ASSERT( d.vkCreateDataGraphPipelinesARM && "Function <vkCreateDataGraphPipelinesARM> requires <VK_ARM_data_graph>" );
29687 # endif
29688
29689 Pipeline pipeline;
29690 Result result = static_cast<Result>( d.vkCreateDataGraphPipelinesARM( m_device,
29691 static_cast<VkDeferredOperationKHR>( deferredOperation ),
29692 static_cast<VkPipelineCache>( pipelineCache ),
29693 1,
29694 reinterpret_cast<const VkDataGraphPipelineCreateInfoARM *>( &createInfo ),
29695 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
29696 reinterpret_cast<VkPipeline *>( &pipeline ) ) );
29697 detail::resultCheck(
29698 result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDataGraphPipelineARMUnique", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } );
29699
29700 return ResultValue<UniqueHandle<Pipeline, Dispatch>>(
29701 result, UniqueHandle<Pipeline, Dispatch>( pipeline, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
29702 }
29703 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
29704 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
29705
29706 // wrapper function for command vkCreateDataGraphPipelineSessionARM, see
29707 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelineSessionARM.html
29708 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
29709 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createDataGraphPipelineSessionARM( const DataGraphPipelineSessionCreateInfoARM * pCreateInfo,
29710 const AllocationCallbacks * pAllocator,
29711 DataGraphPipelineSessionARM * pSession,
29712 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
29713 {
29714 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
29715 return static_cast<Result>( d.vkCreateDataGraphPipelineSessionARM( static_cast<VkDevice>( m_device ),
29716 reinterpret_cast<const VkDataGraphPipelineSessionCreateInfoARM *>( pCreateInfo ),
29717 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
29718 reinterpret_cast<VkDataGraphPipelineSessionARM *>( pSession ) ) );
29719 }
29720
29721 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
29722 // wrapper function for command vkCreateDataGraphPipelineSessionARM, see
29723 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelineSessionARM.html
29724 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
29725 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<DataGraphPipelineSessionARM>::type Device::createDataGraphPipelineSessionARM(
29726 const DataGraphPipelineSessionCreateInfoARM & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
29727 {
29728 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
29729 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
29730 VULKAN_HPP_ASSERT( d.vkCreateDataGraphPipelineSessionARM && "Function <vkCreateDataGraphPipelineSessionARM> requires <VK_ARM_data_graph>" );
29731 # endif
29732
29733 DataGraphPipelineSessionARM session;
29734 Result result =
29735 static_cast<Result>( d.vkCreateDataGraphPipelineSessionARM( m_device,
29736 reinterpret_cast<const VkDataGraphPipelineSessionCreateInfoARM *>( &createInfo ),
29737 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
29738 reinterpret_cast<VkDataGraphPipelineSessionARM *>( &session ) ) );
29739 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDataGraphPipelineSessionARM" );
29740
29741 return detail::createResultValueType( result, std::move( session ) );
29742 }
29743
29744 # ifndef VULKAN_HPP_NO_SMART_HANDLE
29745 // wrapper function for command vkCreateDataGraphPipelineSessionARM, see
29746 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelineSessionARM.html
29747 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
29748 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<DataGraphPipelineSessionARM, Dispatch>>::type
29749 Device::createDataGraphPipelineSessionARMUnique( const DataGraphPipelineSessionCreateInfoARM & createInfo,
29750 Optional<const AllocationCallbacks> allocator,
29751 Dispatch const & d ) const
29752 {
29753 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
29754 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
29755 VULKAN_HPP_ASSERT( d.vkCreateDataGraphPipelineSessionARM && "Function <vkCreateDataGraphPipelineSessionARM> requires <VK_ARM_data_graph>" );
29756 # endif
29757
29758 DataGraphPipelineSessionARM session;
29759 Result result =
29760 static_cast<Result>( d.vkCreateDataGraphPipelineSessionARM( m_device,
29761 reinterpret_cast<const VkDataGraphPipelineSessionCreateInfoARM *>( &createInfo ),
29762 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
29763 reinterpret_cast<VkDataGraphPipelineSessionARM *>( &session ) ) );
29764 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDataGraphPipelineSessionARMUnique" );
29765
29766 return detail::createResultValueType(
29767 result, UniqueHandle<DataGraphPipelineSessionARM, Dispatch>( session, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
29768 }
29769 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
29770 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
29771
29772 // wrapper function for command vkGetDataGraphPipelineSessionBindPointRequirementsARM, see
29773 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineSessionBindPointRequirementsARM.html
29774 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
29775 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
29776 Device::getDataGraphPipelineSessionBindPointRequirementsARM( const DataGraphPipelineSessionBindPointRequirementsInfoARM * pInfo,
29777 uint32_t * pBindPointRequirementCount,
29778 DataGraphPipelineSessionBindPointRequirementARM * pBindPointRequirements,
29779 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
29780 {
29781 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
29782 return static_cast<Result>( d.vkGetDataGraphPipelineSessionBindPointRequirementsARM(
29783 static_cast<VkDevice>( m_device ),
29784 reinterpret_cast<const VkDataGraphPipelineSessionBindPointRequirementsInfoARM *>( pInfo ),
29785 pBindPointRequirementCount,
29786 reinterpret_cast<VkDataGraphPipelineSessionBindPointRequirementARM *>( pBindPointRequirements ) ) );
29787 }
29788
29789 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
29790 // wrapper function for command vkGetDataGraphPipelineSessionBindPointRequirementsARM, see
29791 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineSessionBindPointRequirementsARM.html
29792 template <typename DataGraphPipelineSessionBindPointRequirementARMAllocator,
29793 typename Dispatch,
29794 typename std::enable_if<std::is_same<typename DataGraphPipelineSessionBindPointRequirementARMAllocator::value_type,
29795 DataGraphPipelineSessionBindPointRequirementARM>::value,
29796 int>::type,
29797 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
29798 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
29799 typename ResultValueType<std::vector<DataGraphPipelineSessionBindPointRequirementARM, DataGraphPipelineSessionBindPointRequirementARMAllocator>>::type
29800 Device::getDataGraphPipelineSessionBindPointRequirementsARM( const DataGraphPipelineSessionBindPointRequirementsInfoARM & info, Dispatch const & d ) const
29801 {
29802 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
29803 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
29804 VULKAN_HPP_ASSERT( d.vkGetDataGraphPipelineSessionBindPointRequirementsARM &&
29805 "Function <vkGetDataGraphPipelineSessionBindPointRequirementsARM> requires <VK_ARM_data_graph>" );
29806 # endif
29807
29808 std::vector<DataGraphPipelineSessionBindPointRequirementARM, DataGraphPipelineSessionBindPointRequirementARMAllocator> bindPointRequirements;
29809 uint32_t bindPointRequirementCount;
29810 Result result;
29811 do
29812 {
29813 result = static_cast<Result>( d.vkGetDataGraphPipelineSessionBindPointRequirementsARM(
29814 m_device, reinterpret_cast<const VkDataGraphPipelineSessionBindPointRequirementsInfoARM *>( &info ), &bindPointRequirementCount, nullptr ) );
29815 if ( ( result == Result::eSuccess ) && bindPointRequirementCount )
29816 {
29817 bindPointRequirements.resize( bindPointRequirementCount );
29818 result = static_cast<Result>( d.vkGetDataGraphPipelineSessionBindPointRequirementsARM(
29819 m_device,
29820 reinterpret_cast<const VkDataGraphPipelineSessionBindPointRequirementsInfoARM *>( &info ),
29821 &bindPointRequirementCount,
29822 reinterpret_cast<VkDataGraphPipelineSessionBindPointRequirementARM *>( bindPointRequirements.data() ) ) );
29823 }
29824 } while ( result == Result::eIncomplete );
29825 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getDataGraphPipelineSessionBindPointRequirementsARM" );
29826 VULKAN_HPP_ASSERT( bindPointRequirementCount <= bindPointRequirements.size() );
29827 if ( bindPointRequirementCount < bindPointRequirements.size() )
29828 {
29829 bindPointRequirements.resize( bindPointRequirementCount );
29830 }
29831 return detail::createResultValueType( result, std::move( bindPointRequirements ) );
29832 }
29833
29834 // wrapper function for command vkGetDataGraphPipelineSessionBindPointRequirementsARM, see
29835 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineSessionBindPointRequirementsARM.html
29836 template <typename DataGraphPipelineSessionBindPointRequirementARMAllocator,
29837 typename Dispatch,
29838 typename std::enable_if<std::is_same<typename DataGraphPipelineSessionBindPointRequirementARMAllocator::value_type,
29839 DataGraphPipelineSessionBindPointRequirementARM>::value,
29840 int>::type,
29841 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
29842 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
29843 typename ResultValueType<std::vector<DataGraphPipelineSessionBindPointRequirementARM, DataGraphPipelineSessionBindPointRequirementARMAllocator>>::type
29844 Device::getDataGraphPipelineSessionBindPointRequirementsARM(
29845 const DataGraphPipelineSessionBindPointRequirementsInfoARM & info,
29846 DataGraphPipelineSessionBindPointRequirementARMAllocator & dataGraphPipelineSessionBindPointRequirementARMAllocator,
29847 Dispatch const & d ) const
29848 {
29849 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
29850 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
29851 VULKAN_HPP_ASSERT( d.vkGetDataGraphPipelineSessionBindPointRequirementsARM &&
29852 "Function <vkGetDataGraphPipelineSessionBindPointRequirementsARM> requires <VK_ARM_data_graph>" );
29853 # endif
29854
29855 std::vector<DataGraphPipelineSessionBindPointRequirementARM, DataGraphPipelineSessionBindPointRequirementARMAllocator> bindPointRequirements(
29856 dataGraphPipelineSessionBindPointRequirementARMAllocator );
29857 uint32_t bindPointRequirementCount;
29858 Result result;
29859 do
29860 {
29861 result = static_cast<Result>( d.vkGetDataGraphPipelineSessionBindPointRequirementsARM(
29862 m_device, reinterpret_cast<const VkDataGraphPipelineSessionBindPointRequirementsInfoARM *>( &info ), &bindPointRequirementCount, nullptr ) );
29863 if ( ( result == Result::eSuccess ) && bindPointRequirementCount )
29864 {
29865 bindPointRequirements.resize( bindPointRequirementCount );
29866 result = static_cast<Result>( d.vkGetDataGraphPipelineSessionBindPointRequirementsARM(
29867 m_device,
29868 reinterpret_cast<const VkDataGraphPipelineSessionBindPointRequirementsInfoARM *>( &info ),
29869 &bindPointRequirementCount,
29870 reinterpret_cast<VkDataGraphPipelineSessionBindPointRequirementARM *>( bindPointRequirements.data() ) ) );
29871 }
29872 } while ( result == Result::eIncomplete );
29873 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getDataGraphPipelineSessionBindPointRequirementsARM" );
29874 VULKAN_HPP_ASSERT( bindPointRequirementCount <= bindPointRequirements.size() );
29875 if ( bindPointRequirementCount < bindPointRequirements.size() )
29876 {
29877 bindPointRequirements.resize( bindPointRequirementCount );
29878 }
29879 return detail::createResultValueType( result, std::move( bindPointRequirements ) );
29880 }
29881 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
29882
29883 // wrapper function for command vkGetDataGraphPipelineSessionMemoryRequirementsARM, see
29884 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineSessionMemoryRequirementsARM.html
29885 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
29886 VULKAN_HPP_INLINE void Device::getDataGraphPipelineSessionMemoryRequirementsARM( const DataGraphPipelineSessionMemoryRequirementsInfoARM * pInfo,
29887 MemoryRequirements2 * pMemoryRequirements,
29888 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
29889 {
29890 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
29891 d.vkGetDataGraphPipelineSessionMemoryRequirementsARM( static_cast<VkDevice>( m_device ),
29892 reinterpret_cast<const VkDataGraphPipelineSessionMemoryRequirementsInfoARM *>( pInfo ),
29893 reinterpret_cast<VkMemoryRequirements2 *>( pMemoryRequirements ) );
29894 }
29895
29896 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
29897 // wrapper function for command vkGetDataGraphPipelineSessionMemoryRequirementsARM, see
29898 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineSessionMemoryRequirementsARM.html
29899 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
29900 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 Device::getDataGraphPipelineSessionMemoryRequirementsARM(
29901 const DataGraphPipelineSessionMemoryRequirementsInfoARM & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
29902 {
29903 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
29904 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
29905 VULKAN_HPP_ASSERT( d.vkGetDataGraphPipelineSessionMemoryRequirementsARM &&
29906 "Function <vkGetDataGraphPipelineSessionMemoryRequirementsARM> requires <VK_ARM_data_graph>" );
29907 # endif
29908
29909 MemoryRequirements2 memoryRequirements;
29910 d.vkGetDataGraphPipelineSessionMemoryRequirementsARM( m_device,
29911 reinterpret_cast<const VkDataGraphPipelineSessionMemoryRequirementsInfoARM *>( &info ),
29912 reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
29913
29914 return memoryRequirements;
29915 }
29916
29917 // wrapper function for command vkGetDataGraphPipelineSessionMemoryRequirementsARM, see
29918 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineSessionMemoryRequirementsARM.html
29919 template <typename X, typename Y, typename... Z, typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
29920 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...>
29921 Device::getDataGraphPipelineSessionMemoryRequirementsARM( const DataGraphPipelineSessionMemoryRequirementsInfoARM & info,
29922 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
29923 {
29924 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
29925 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
29926 VULKAN_HPP_ASSERT( d.vkGetDataGraphPipelineSessionMemoryRequirementsARM &&
29927 "Function <vkGetDataGraphPipelineSessionMemoryRequirementsARM> requires <VK_ARM_data_graph>" );
29928 # endif
29929
29930 StructureChain<X, Y, Z...> structureChain;
29931 MemoryRequirements2 & memoryRequirements = structureChain.template get<MemoryRequirements2>();
29932 d.vkGetDataGraphPipelineSessionMemoryRequirementsARM( m_device,
29933 reinterpret_cast<const VkDataGraphPipelineSessionMemoryRequirementsInfoARM *>( &info ),
29934 reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
29935
29936 return structureChain;
29937 }
29938 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
29939
29940 // wrapper function for command vkBindDataGraphPipelineSessionMemoryARM, see
29941 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindDataGraphPipelineSessionMemoryARM.html
29942 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
29943 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::bindDataGraphPipelineSessionMemoryARM( uint32_t bindInfoCount,
29944 const BindDataGraphPipelineSessionMemoryInfoARM * pBindInfos,
29945 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
29946 {
29947 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
29948 return static_cast<Result>( d.vkBindDataGraphPipelineSessionMemoryARM(
29949 static_cast<VkDevice>( m_device ), bindInfoCount, reinterpret_cast<const VkBindDataGraphPipelineSessionMemoryInfoARM *>( pBindInfos ) ) );
29950 }
29951
29952 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
29953 // wrapper function for command vkBindDataGraphPipelineSessionMemoryARM, see
29954 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindDataGraphPipelineSessionMemoryARM.html
29955 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
29956 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
29957 Device::bindDataGraphPipelineSessionMemoryARM( ArrayProxy<const BindDataGraphPipelineSessionMemoryInfoARM> const & bindInfos, Dispatch const & d ) const
29958 {
29959 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
29960 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
29961 VULKAN_HPP_ASSERT( d.vkBindDataGraphPipelineSessionMemoryARM && "Function <vkBindDataGraphPipelineSessionMemoryARM> requires <VK_ARM_data_graph>" );
29962 # endif
29963
29964 Result result = static_cast<Result>( d.vkBindDataGraphPipelineSessionMemoryARM(
29965 m_device, bindInfos.size(), reinterpret_cast<const VkBindDataGraphPipelineSessionMemoryInfoARM *>( bindInfos.data() ) ) );
29966 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindDataGraphPipelineSessionMemoryARM" );
29967
29968 return detail::createResultValueType( result );
29969 }
29970 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
29971
29972 // wrapper function for command vkDestroyDataGraphPipelineSessionARM, see
29973 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDataGraphPipelineSessionARM.html
29974 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
29975 VULKAN_HPP_INLINE void Device::destroyDataGraphPipelineSessionARM( DataGraphPipelineSessionARM session,
29976 const AllocationCallbacks * pAllocator,
29977 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
29978 {
29979 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
29980 d.vkDestroyDataGraphPipelineSessionARM(
29981 static_cast<VkDevice>( m_device ), static_cast<VkDataGraphPipelineSessionARM>( session ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
29982 }
29983
29984 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
29985 // wrapper function for command vkDestroyDataGraphPipelineSessionARM, see
29986 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDataGraphPipelineSessionARM.html
29987 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
29988 VULKAN_HPP_INLINE void Device::destroyDataGraphPipelineSessionARM( DataGraphPipelineSessionARM session,
29989 Optional<const AllocationCallbacks> allocator,
29990 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
29991 {
29992 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
29993 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
29994 VULKAN_HPP_ASSERT( d.vkDestroyDataGraphPipelineSessionARM && "Function <vkDestroyDataGraphPipelineSessionARM> requires <VK_ARM_data_graph>" );
29995 # endif
29996
29997 d.vkDestroyDataGraphPipelineSessionARM(
29998 m_device, static_cast<VkDataGraphPipelineSessionARM>( session ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
29999 }
30000 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
30001
30002 // wrapper function for command vkDestroyDataGraphPipelineSessionARM, see
30003 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDataGraphPipelineSessionARM.html
30004 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
30005 VULKAN_HPP_INLINE void
30006 Device::destroy( DataGraphPipelineSessionARM session, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
30007 {
30008 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
30009 d.vkDestroyDataGraphPipelineSessionARM(
30010 static_cast<VkDevice>( m_device ), static_cast<VkDataGraphPipelineSessionARM>( session ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
30011 }
30012
30013 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
30014 // wrapper function for command vkDestroyDataGraphPipelineSessionARM, see
30015 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDataGraphPipelineSessionARM.html
30016 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
30017 VULKAN_HPP_INLINE void
30018 Device::destroy( DataGraphPipelineSessionARM session, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
30019 {
30020 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
30021 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
30022 VULKAN_HPP_ASSERT( d.vkDestroyDataGraphPipelineSessionARM && "Function <vkDestroyDataGraphPipelineSessionARM> requires <VK_ARM_data_graph>" );
30023 # endif
30024
30025 d.vkDestroyDataGraphPipelineSessionARM(
30026 m_device, static_cast<VkDataGraphPipelineSessionARM>( session ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
30027 }
30028 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
30029
30030 // wrapper function for command vkCmdDispatchDataGraphARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchDataGraphARM.html
30031 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
30032 VULKAN_HPP_INLINE void CommandBuffer::dispatchDataGraphARM( DataGraphPipelineSessionARM session,
30033 const DataGraphPipelineDispatchInfoARM * pInfo,
30034 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
30035 {
30036 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
30037 d.vkCmdDispatchDataGraphARM( static_cast<VkCommandBuffer>( m_commandBuffer ),
30038 static_cast<VkDataGraphPipelineSessionARM>( session ),
30039 reinterpret_cast<const VkDataGraphPipelineDispatchInfoARM *>( pInfo ) );
30040 }
30041
30042 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
30043 // wrapper function for command vkCmdDispatchDataGraphARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchDataGraphARM.html
30044 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
30045 VULKAN_HPP_INLINE void CommandBuffer::dispatchDataGraphARM( DataGraphPipelineSessionARM session,
30046 Optional<const DataGraphPipelineDispatchInfoARM> info,
30047 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
30048 {
30049 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
30050 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
30051 VULKAN_HPP_ASSERT( d.vkCmdDispatchDataGraphARM && "Function <vkCmdDispatchDataGraphARM> requires <VK_ARM_data_graph>" );
30052 # endif
30053
30054 d.vkCmdDispatchDataGraphARM(
30055 m_commandBuffer, static_cast<VkDataGraphPipelineSessionARM>( session ), reinterpret_cast<const VkDataGraphPipelineDispatchInfoARM *>( info.get() ) );
30056 }
30057 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
30058
30059 // wrapper function for command vkGetDataGraphPipelineAvailablePropertiesARM, see
30060 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineAvailablePropertiesARM.html
30061 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
30062 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getDataGraphPipelineAvailablePropertiesARM( const DataGraphPipelineInfoARM * pPipelineInfo,
30063 uint32_t * pPropertiesCount,
30064 DataGraphPipelinePropertyARM * pProperties,
30065 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
30066 {
30067 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
30068 return static_cast<Result>( d.vkGetDataGraphPipelineAvailablePropertiesARM( static_cast<VkDevice>( m_device ),
30069 reinterpret_cast<const VkDataGraphPipelineInfoARM *>( pPipelineInfo ),
30070 pPropertiesCount,
30071 reinterpret_cast<VkDataGraphPipelinePropertyARM *>( pProperties ) ) );
30072 }
30073
30074 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
30075 // wrapper function for command vkGetDataGraphPipelineAvailablePropertiesARM, see
30076 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineAvailablePropertiesARM.html
30077 template <typename DataGraphPipelinePropertyARMAllocator,
30078 typename Dispatch,
30079 typename std::enable_if<std::is_same<typename DataGraphPipelinePropertyARMAllocator::value_type, DataGraphPipelinePropertyARM>::value, int>::type,
30080 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
30081 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<DataGraphPipelinePropertyARM, DataGraphPipelinePropertyARMAllocator>>::type
30082 Device::getDataGraphPipelineAvailablePropertiesARM( const DataGraphPipelineInfoARM & pipelineInfo, Dispatch const & d ) const
30083 {
30084 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
30085 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
30086 VULKAN_HPP_ASSERT( d.vkGetDataGraphPipelineAvailablePropertiesARM &&
30087 "Function <vkGetDataGraphPipelineAvailablePropertiesARM> requires <VK_ARM_data_graph>" );
30088 # endif
30089
30090 std::vector<DataGraphPipelinePropertyARM, DataGraphPipelinePropertyARMAllocator> properties;
30091 uint32_t propertiesCount;
30092 Result result;
30093 do
30094 {
30095 result = static_cast<Result>( d.vkGetDataGraphPipelineAvailablePropertiesARM(
30096 m_device, reinterpret_cast<const VkDataGraphPipelineInfoARM *>( &pipelineInfo ), &propertiesCount, nullptr ) );
30097 if ( ( result == Result::eSuccess ) && propertiesCount )
30098 {
30099 properties.resize( propertiesCount );
30100 result =
30101 static_cast<Result>( d.vkGetDataGraphPipelineAvailablePropertiesARM( m_device,
30102 reinterpret_cast<const VkDataGraphPipelineInfoARM *>( &pipelineInfo ),
30103 &propertiesCount,
30104 reinterpret_cast<VkDataGraphPipelinePropertyARM *>( properties.data() ) ) );
30105 }
30106 } while ( result == Result::eIncomplete );
30107 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getDataGraphPipelineAvailablePropertiesARM" );
30108 VULKAN_HPP_ASSERT( propertiesCount <= properties.size() );
30109 if ( propertiesCount < properties.size() )
30110 {
30111 properties.resize( propertiesCount );
30112 }
30113 return detail::createResultValueType( result, std::move( properties ) );
30114 }
30115
30116 // wrapper function for command vkGetDataGraphPipelineAvailablePropertiesARM, see
30117 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineAvailablePropertiesARM.html
30118 template <typename DataGraphPipelinePropertyARMAllocator,
30119 typename Dispatch,
30120 typename std::enable_if<std::is_same<typename DataGraphPipelinePropertyARMAllocator::value_type, DataGraphPipelinePropertyARM>::value, int>::type,
30121 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
30122 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<DataGraphPipelinePropertyARM, DataGraphPipelinePropertyARMAllocator>>::type
30123 Device::getDataGraphPipelineAvailablePropertiesARM( const DataGraphPipelineInfoARM & pipelineInfo,
30124 DataGraphPipelinePropertyARMAllocator & dataGraphPipelinePropertyARMAllocator,
30125 Dispatch const & d ) const
30126 {
30127 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
30128 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
30129 VULKAN_HPP_ASSERT( d.vkGetDataGraphPipelineAvailablePropertiesARM &&
30130 "Function <vkGetDataGraphPipelineAvailablePropertiesARM> requires <VK_ARM_data_graph>" );
30131 # endif
30132
30133 std::vector<DataGraphPipelinePropertyARM, DataGraphPipelinePropertyARMAllocator> properties( dataGraphPipelinePropertyARMAllocator );
30134 uint32_t propertiesCount;
30135 Result result;
30136 do
30137 {
30138 result = static_cast<Result>( d.vkGetDataGraphPipelineAvailablePropertiesARM(
30139 m_device, reinterpret_cast<const VkDataGraphPipelineInfoARM *>( &pipelineInfo ), &propertiesCount, nullptr ) );
30140 if ( ( result == Result::eSuccess ) && propertiesCount )
30141 {
30142 properties.resize( propertiesCount );
30143 result =
30144 static_cast<Result>( d.vkGetDataGraphPipelineAvailablePropertiesARM( m_device,
30145 reinterpret_cast<const VkDataGraphPipelineInfoARM *>( &pipelineInfo ),
30146 &propertiesCount,
30147 reinterpret_cast<VkDataGraphPipelinePropertyARM *>( properties.data() ) ) );
30148 }
30149 } while ( result == Result::eIncomplete );
30150 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getDataGraphPipelineAvailablePropertiesARM" );
30151 VULKAN_HPP_ASSERT( propertiesCount <= properties.size() );
30152 if ( propertiesCount < properties.size() )
30153 {
30154 properties.resize( propertiesCount );
30155 }
30156 return detail::createResultValueType( result, std::move( properties ) );
30157 }
30158 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
30159
30160 // wrapper function for command vkGetDataGraphPipelinePropertiesARM, see
30161 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelinePropertiesARM.html
30162 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
30163 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getDataGraphPipelinePropertiesARM( const DataGraphPipelineInfoARM * pPipelineInfo,
30164 uint32_t propertiesCount,
30165 DataGraphPipelinePropertyQueryResultARM * pProperties,
30166 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
30167 {
30168 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
30169 return static_cast<Result>( d.vkGetDataGraphPipelinePropertiesARM( static_cast<VkDevice>( m_device ),
30170 reinterpret_cast<const VkDataGraphPipelineInfoARM *>( pPipelineInfo ),
30171 propertiesCount,
30172 reinterpret_cast<VkDataGraphPipelinePropertyQueryResultARM *>( pProperties ) ) );
30173 }
30174
30175 // wrapper function for command vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM, see
30176 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM.html
30177 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
30178 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
30179 PhysicalDevice::getQueueFamilyDataGraphPropertiesARM( uint32_t queueFamilyIndex,
30180 uint32_t * pQueueFamilyDataGraphPropertyCount,
30181 QueueFamilyDataGraphPropertiesARM * pQueueFamilyDataGraphProperties,
30182 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
30183 {
30184 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
30185 return static_cast<Result>(
30186 d.vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM( static_cast<VkPhysicalDevice>( m_physicalDevice ),
30187 queueFamilyIndex,
30188 pQueueFamilyDataGraphPropertyCount,
30189 reinterpret_cast<VkQueueFamilyDataGraphPropertiesARM *>( pQueueFamilyDataGraphProperties ) ) );
30190 }
30191
30192 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
30193 // wrapper function for command vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM, see
30194 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM.html
30195 template <
30196 typename QueueFamilyDataGraphPropertiesARMAllocator,
30197 typename Dispatch,
30198 typename std::enable_if<std::is_same<typename QueueFamilyDataGraphPropertiesARMAllocator::value_type, QueueFamilyDataGraphPropertiesARM>::value, int>::type,
30199 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
30200 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
30201 typename ResultValueType<std::vector<QueueFamilyDataGraphPropertiesARM, QueueFamilyDataGraphPropertiesARMAllocator>>::type
30202 PhysicalDevice::getQueueFamilyDataGraphPropertiesARM( uint32_t queueFamilyIndex, Dispatch const & d ) const
30203 {
30204 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
30205 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
30206 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM &&
30207 "Function <vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM> requires <VK_ARM_data_graph>" );
30208 # endif
30209
30210 std::vector<QueueFamilyDataGraphPropertiesARM, QueueFamilyDataGraphPropertiesARMAllocator> queueFamilyDataGraphProperties;
30211 uint32_t queueFamilyDataGraphPropertyCount;
30212 Result result;
30213 do
30214 {
30215 result = static_cast<Result>(
30216 d.vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM( m_physicalDevice, queueFamilyIndex, &queueFamilyDataGraphPropertyCount, nullptr ) );
30217 if ( ( result == Result::eSuccess ) && queueFamilyDataGraphPropertyCount )
30218 {
30219 queueFamilyDataGraphProperties.resize( queueFamilyDataGraphPropertyCount );
30220 result = static_cast<Result>( d.vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM(
30221 m_physicalDevice,
30222 queueFamilyIndex,
30223 &queueFamilyDataGraphPropertyCount,
30224 reinterpret_cast<VkQueueFamilyDataGraphPropertiesARM *>( queueFamilyDataGraphProperties.data() ) ) );
30225 }
30226 } while ( result == Result::eIncomplete );
30227 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getQueueFamilyDataGraphPropertiesARM" );
30228 VULKAN_HPP_ASSERT( queueFamilyDataGraphPropertyCount <= queueFamilyDataGraphProperties.size() );
30229 if ( queueFamilyDataGraphPropertyCount < queueFamilyDataGraphProperties.size() )
30230 {
30231 queueFamilyDataGraphProperties.resize( queueFamilyDataGraphPropertyCount );
30232 }
30233 return detail::createResultValueType( result, std::move( queueFamilyDataGraphProperties ) );
30234 }
30235
30236 // wrapper function for command vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM, see
30237 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM.html
30238 template <
30239 typename QueueFamilyDataGraphPropertiesARMAllocator,
30240 typename Dispatch,
30241 typename std::enable_if<std::is_same<typename QueueFamilyDataGraphPropertiesARMAllocator::value_type, QueueFamilyDataGraphPropertiesARM>::value, int>::type,
30242 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
30243 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
30244 typename ResultValueType<std::vector<QueueFamilyDataGraphPropertiesARM, QueueFamilyDataGraphPropertiesARMAllocator>>::type
30245 PhysicalDevice::getQueueFamilyDataGraphPropertiesARM( uint32_t queueFamilyIndex,
30246 QueueFamilyDataGraphPropertiesARMAllocator & queueFamilyDataGraphPropertiesARMAllocator,
30247 Dispatch const & d ) const
30248 {
30249 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
30250 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
30251 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM &&
30252 "Function <vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM> requires <VK_ARM_data_graph>" );
30253 # endif
30254
30255 std::vector<QueueFamilyDataGraphPropertiesARM, QueueFamilyDataGraphPropertiesARMAllocator> queueFamilyDataGraphProperties(
30256 queueFamilyDataGraphPropertiesARMAllocator );
30257 uint32_t queueFamilyDataGraphPropertyCount;
30258 Result result;
30259 do
30260 {
30261 result = static_cast<Result>(
30262 d.vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM( m_physicalDevice, queueFamilyIndex, &queueFamilyDataGraphPropertyCount, nullptr ) );
30263 if ( ( result == Result::eSuccess ) && queueFamilyDataGraphPropertyCount )
30264 {
30265 queueFamilyDataGraphProperties.resize( queueFamilyDataGraphPropertyCount );
30266 result = static_cast<Result>( d.vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM(
30267 m_physicalDevice,
30268 queueFamilyIndex,
30269 &queueFamilyDataGraphPropertyCount,
30270 reinterpret_cast<VkQueueFamilyDataGraphPropertiesARM *>( queueFamilyDataGraphProperties.data() ) ) );
30271 }
30272 } while ( result == Result::eIncomplete );
30273 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getQueueFamilyDataGraphPropertiesARM" );
30274 VULKAN_HPP_ASSERT( queueFamilyDataGraphPropertyCount <= queueFamilyDataGraphProperties.size() );
30275 if ( queueFamilyDataGraphPropertyCount < queueFamilyDataGraphProperties.size() )
30276 {
30277 queueFamilyDataGraphProperties.resize( queueFamilyDataGraphPropertyCount );
30278 }
30279 return detail::createResultValueType( result, std::move( queueFamilyDataGraphProperties ) );
30280 }
30281 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
30282
30283 // wrapper function for command vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM, see
30284 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM.html
30285 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
30286 VULKAN_HPP_INLINE void PhysicalDevice::getQueueFamilyDataGraphProcessingEnginePropertiesARM(
30287 const PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM * pQueueFamilyDataGraphProcessingEngineInfo,
30288 QueueFamilyDataGraphProcessingEnginePropertiesARM * pQueueFamilyDataGraphProcessingEngineProperties,
30289 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
30290 {
30291 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
30292 d.vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM(
30293 static_cast<VkPhysicalDevice>( m_physicalDevice ),
30294 reinterpret_cast<const VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM *>( pQueueFamilyDataGraphProcessingEngineInfo ),
30295 reinterpret_cast<VkQueueFamilyDataGraphProcessingEnginePropertiesARM *>( pQueueFamilyDataGraphProcessingEngineProperties ) );
30296 }
30297
30298 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
30299 // wrapper function for command vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM, see
30300 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM.html
30301 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
30302 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE QueueFamilyDataGraphProcessingEnginePropertiesARM PhysicalDevice::getQueueFamilyDataGraphProcessingEnginePropertiesARM(
30303 const PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM & queueFamilyDataGraphProcessingEngineInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
30304 {
30305 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
30306 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
30307 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM &&
30308 "Function <vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM> requires <VK_ARM_data_graph>" );
30309 # endif
30310
30311 QueueFamilyDataGraphProcessingEnginePropertiesARM queueFamilyDataGraphProcessingEngineProperties;
30312 d.vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM(
30313 m_physicalDevice,
30314 reinterpret_cast<const VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM *>( &queueFamilyDataGraphProcessingEngineInfo ),
30315 reinterpret_cast<VkQueueFamilyDataGraphProcessingEnginePropertiesARM *>( &queueFamilyDataGraphProcessingEngineProperties ) );
30316
30317 return queueFamilyDataGraphProcessingEngineProperties;
30318 }
30319 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
30320
30321 //=== VK_EXT_attachment_feedback_loop_dynamic_state ===
30322
30323 // wrapper function for command vkCmdSetAttachmentFeedbackLoopEnableEXT, see
30324 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetAttachmentFeedbackLoopEnableEXT.html
30325 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
30326 VULKAN_HPP_INLINE void CommandBuffer::setAttachmentFeedbackLoopEnableEXT( ImageAspectFlags aspectMask, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
30327 {
30328 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
30329 d.vkCmdSetAttachmentFeedbackLoopEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkImageAspectFlags>( aspectMask ) );
30330 }
30331
30332 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
30333 //=== VK_QNX_external_memory_screen_buffer ===
30334
30335 // wrapper function for command vkGetScreenBufferPropertiesQNX, see
30336 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetScreenBufferPropertiesQNX.html
30337 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
30338 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getScreenBufferPropertiesQNX( const struct _screen_buffer * buffer,
30339 ScreenBufferPropertiesQNX * pProperties,
30340 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
30341 {
30342 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
30343 return static_cast<Result>(
30344 d.vkGetScreenBufferPropertiesQNX( static_cast<VkDevice>( m_device ), buffer, reinterpret_cast<VkScreenBufferPropertiesQNX *>( pProperties ) ) );
30345 }
30346
30347 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
30348 // wrapper function for command vkGetScreenBufferPropertiesQNX, see
30349 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetScreenBufferPropertiesQNX.html
30350 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
30351 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<ScreenBufferPropertiesQNX>::type
30352 Device::getScreenBufferPropertiesQNX( const struct _screen_buffer & buffer, Dispatch const & d ) const
30353 {
30354 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
30355 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
30356 VULKAN_HPP_ASSERT( d.vkGetScreenBufferPropertiesQNX && "Function <vkGetScreenBufferPropertiesQNX> requires <VK_QNX_external_memory_screen_buffer>" );
30357 # endif
30358
30359 ScreenBufferPropertiesQNX properties;
30360 Result result =
30361 static_cast<Result>( d.vkGetScreenBufferPropertiesQNX( m_device, &buffer, reinterpret_cast<VkScreenBufferPropertiesQNX *>( &properties ) ) );
30362 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getScreenBufferPropertiesQNX" );
30363
30364 return detail::createResultValueType( result, std::move( properties ) );
30365 }
30366
30367 // wrapper function for command vkGetScreenBufferPropertiesQNX, see
30368 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetScreenBufferPropertiesQNX.html
30369 template <typename X, typename Y, typename... Z, typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
30370 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<StructureChain<X, Y, Z...>>::type
30371 Device::getScreenBufferPropertiesQNX( const struct _screen_buffer & buffer, Dispatch const & d ) const
30372 {
30373 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
30374 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
30375 VULKAN_HPP_ASSERT( d.vkGetScreenBufferPropertiesQNX && "Function <vkGetScreenBufferPropertiesQNX> requires <VK_QNX_external_memory_screen_buffer>" );
30376 # endif
30377
30378 StructureChain<X, Y, Z...> structureChain;
30379 ScreenBufferPropertiesQNX & properties = structureChain.template get<ScreenBufferPropertiesQNX>();
30380 Result result =
30381 static_cast<Result>( d.vkGetScreenBufferPropertiesQNX( m_device, &buffer, reinterpret_cast<VkScreenBufferPropertiesQNX *>( &properties ) ) );
30382 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getScreenBufferPropertiesQNX" );
30383
30384 return detail::createResultValueType( result, std::move( structureChain ) );
30385 }
30386 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
30387 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
30388
30389 //=== VK_KHR_line_rasterization ===
30390
30391 // wrapper function for command vkCmdSetLineStippleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineStippleKHR.html
30392 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
30393 VULKAN_HPP_INLINE void
30394 CommandBuffer::setLineStippleKHR( uint32_t lineStippleFactor, uint16_t lineStipplePattern, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
30395 {
30396 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
30397 d.vkCmdSetLineStippleKHR( static_cast<VkCommandBuffer>( m_commandBuffer ), lineStippleFactor, lineStipplePattern );
30398 }
30399
30400 //=== VK_KHR_calibrated_timestamps ===
30401
30402 // wrapper function for command vkGetPhysicalDeviceCalibrateableTimeDomainsKHR, see
30403 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCalibrateableTimeDomainsKHR.html
30404 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
30405 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getCalibrateableTimeDomainsKHR( uint32_t * pTimeDomainCount,
30406 TimeDomainKHR * pTimeDomains,
30407 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
30408 {
30409 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
30410 return static_cast<Result>( d.vkGetPhysicalDeviceCalibrateableTimeDomainsKHR(
30411 static_cast<VkPhysicalDevice>( m_physicalDevice ), pTimeDomainCount, reinterpret_cast<VkTimeDomainKHR *>( pTimeDomains ) ) );
30412 }
30413
30414 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
30415 // wrapper function for command vkGetPhysicalDeviceCalibrateableTimeDomainsKHR, see
30416 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCalibrateableTimeDomainsKHR.html
30417 template <typename TimeDomainKHRAllocator,
30418 typename Dispatch,
30419 typename std::enable_if<std::is_same<typename TimeDomainKHRAllocator::value_type, TimeDomainKHR>::value, int>::type,
30420 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
30421 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<TimeDomainKHR, TimeDomainKHRAllocator>>::type
30422 PhysicalDevice::getCalibrateableTimeDomainsKHR( Dispatch const & d ) const
30423 {
30424 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
30425 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
30426 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceCalibrateableTimeDomainsKHR &&
30427 "Function <vkGetPhysicalDeviceCalibrateableTimeDomainsKHR> requires <VK_EXT_calibrated_timestamps> or <VK_KHR_calibrated_timestamps>" );
30428 # endif
30429
30430 std::vector<TimeDomainKHR, TimeDomainKHRAllocator> timeDomains;
30431 uint32_t timeDomainCount;
30432 Result result;
30433 do
30434 {
30435 result = static_cast<Result>( d.vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( m_physicalDevice, &timeDomainCount, nullptr ) );
30436 if ( ( result == Result::eSuccess ) && timeDomainCount )
30437 {
30438 timeDomains.resize( timeDomainCount );
30439 result = static_cast<Result>(
30440 d.vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( m_physicalDevice, &timeDomainCount, reinterpret_cast<VkTimeDomainKHR *>( timeDomains.data() ) ) );
30441 }
30442 } while ( result == Result::eIncomplete );
30443 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCalibrateableTimeDomainsKHR" );
30444 VULKAN_HPP_ASSERT( timeDomainCount <= timeDomains.size() );
30445 if ( timeDomainCount < timeDomains.size() )
30446 {
30447 timeDomains.resize( timeDomainCount );
30448 }
30449 return detail::createResultValueType( result, std::move( timeDomains ) );
30450 }
30451
30452 // wrapper function for command vkGetPhysicalDeviceCalibrateableTimeDomainsKHR, see
30453 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCalibrateableTimeDomainsKHR.html
30454 template <typename TimeDomainKHRAllocator,
30455 typename Dispatch,
30456 typename std::enable_if<std::is_same<typename TimeDomainKHRAllocator::value_type, TimeDomainKHR>::value, int>::type,
30457 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
30458 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<TimeDomainKHR, TimeDomainKHRAllocator>>::type
30459 PhysicalDevice::getCalibrateableTimeDomainsKHR( TimeDomainKHRAllocator & timeDomainKHRAllocator, Dispatch const & d ) const
30460 {
30461 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
30462 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
30463 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceCalibrateableTimeDomainsKHR &&
30464 "Function <vkGetPhysicalDeviceCalibrateableTimeDomainsKHR> requires <VK_EXT_calibrated_timestamps> or <VK_KHR_calibrated_timestamps>" );
30465 # endif
30466
30467 std::vector<TimeDomainKHR, TimeDomainKHRAllocator> timeDomains( timeDomainKHRAllocator );
30468 uint32_t timeDomainCount;
30469 Result result;
30470 do
30471 {
30472 result = static_cast<Result>( d.vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( m_physicalDevice, &timeDomainCount, nullptr ) );
30473 if ( ( result == Result::eSuccess ) && timeDomainCount )
30474 {
30475 timeDomains.resize( timeDomainCount );
30476 result = static_cast<Result>(
30477 d.vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( m_physicalDevice, &timeDomainCount, reinterpret_cast<VkTimeDomainKHR *>( timeDomains.data() ) ) );
30478 }
30479 } while ( result == Result::eIncomplete );
30480 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCalibrateableTimeDomainsKHR" );
30481 VULKAN_HPP_ASSERT( timeDomainCount <= timeDomains.size() );
30482 if ( timeDomainCount < timeDomains.size() )
30483 {
30484 timeDomains.resize( timeDomainCount );
30485 }
30486 return detail::createResultValueType( result, std::move( timeDomains ) );
30487 }
30488 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
30489
30490 // wrapper function for command vkGetCalibratedTimestampsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsKHR.html
30491 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
30492 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getCalibratedTimestampsKHR( uint32_t timestampCount,
30493 const CalibratedTimestampInfoKHR * pTimestampInfos,
30494 uint64_t * pTimestamps,
30495 uint64_t * pMaxDeviation,
30496 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
30497 {
30498 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
30499 return static_cast<Result>( d.vkGetCalibratedTimestampsKHR( static_cast<VkDevice>( m_device ),
30500 timestampCount,
30501 reinterpret_cast<const VkCalibratedTimestampInfoKHR *>( pTimestampInfos ),
30502 pTimestamps,
30503 pMaxDeviation ) );
30504 }
30505
30506 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
30507 // wrapper function for command vkGetCalibratedTimestampsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsKHR.html
30508 template <typename Uint64_tAllocator,
30509 typename Dispatch,
30510 typename std::enable_if<std::is_same<typename Uint64_tAllocator::value_type, uint64_t>::value, int>::type,
30511 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
30512 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type
30513 Device::getCalibratedTimestampsKHR( ArrayProxy<const CalibratedTimestampInfoKHR> const & timestampInfos, Dispatch const & d ) const
30514 {
30515 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
30516 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
30517 VULKAN_HPP_ASSERT( d.vkGetCalibratedTimestampsKHR &&
30518 "Function <vkGetCalibratedTimestampsKHR> requires <VK_EXT_calibrated_timestamps> or <VK_KHR_calibrated_timestamps>" );
30519 # endif
30520
30521 std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t> data_(
30522 std::piecewise_construct, std::forward_as_tuple( timestampInfos.size() ), std::forward_as_tuple( 0 ) );
30523 std::vector<uint64_t, Uint64_tAllocator> & timestamps = data_.first;
30524 uint64_t & maxDeviation = data_.second;
30525 Result result = static_cast<Result>( d.vkGetCalibratedTimestampsKHR(
30526 m_device, timestampInfos.size(), reinterpret_cast<const VkCalibratedTimestampInfoKHR *>( timestampInfos.data() ), timestamps.data(), &maxDeviation ) );
30527 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsKHR" );
30528
30529 return detail::createResultValueType( result, std::move( data_ ) );
30530 }
30531
30532 // wrapper function for command vkGetCalibratedTimestampsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsKHR.html
30533 template <typename Uint64_tAllocator,
30534 typename Dispatch,
30535 typename std::enable_if<std::is_same<typename Uint64_tAllocator::value_type, uint64_t>::value, int>::type,
30536 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
30537 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type
30538 Device::getCalibratedTimestampsKHR( ArrayProxy<const CalibratedTimestampInfoKHR> const & timestampInfos,
30539 Uint64_tAllocator & uint64_tAllocator,
30540 Dispatch const & d ) const
30541 {
30542 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
30543 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
30544 VULKAN_HPP_ASSERT( d.vkGetCalibratedTimestampsKHR &&
30545 "Function <vkGetCalibratedTimestampsKHR> requires <VK_EXT_calibrated_timestamps> or <VK_KHR_calibrated_timestamps>" );
30546 # endif
30547
30548 std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t> data_(
30549 std::piecewise_construct, std::forward_as_tuple( timestampInfos.size(), uint64_tAllocator ), std::forward_as_tuple( 0 ) );
30550 std::vector<uint64_t, Uint64_tAllocator> & timestamps = data_.first;
30551 uint64_t & maxDeviation = data_.second;
30552 Result result = static_cast<Result>( d.vkGetCalibratedTimestampsKHR(
30553 m_device, timestampInfos.size(), reinterpret_cast<const VkCalibratedTimestampInfoKHR *>( timestampInfos.data() ), timestamps.data(), &maxDeviation ) );
30554 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsKHR" );
30555
30556 return detail::createResultValueType( result, std::move( data_ ) );
30557 }
30558
30559 // wrapper function for command vkGetCalibratedTimestampsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsKHR.html
30560 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
30561 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::pair<uint64_t, uint64_t>>::type
30562 Device::getCalibratedTimestampKHR( const CalibratedTimestampInfoKHR & timestampInfo, Dispatch const & d ) const
30563 {
30564 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
30565 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
30566 VULKAN_HPP_ASSERT( d.vkGetCalibratedTimestampsKHR &&
30567 "Function <vkGetCalibratedTimestampsKHR> requires <VK_EXT_calibrated_timestamps> or <VK_KHR_calibrated_timestamps>" );
30568 # endif
30569
30570 std::pair<uint64_t, uint64_t> data_;
30571 uint64_t & timestamp = data_.first;
30572 uint64_t & maxDeviation = data_.second;
30573 Result result = static_cast<Result>(
30574 d.vkGetCalibratedTimestampsKHR( m_device, 1, reinterpret_cast<const VkCalibratedTimestampInfoKHR *>( &timestampInfo ), &timestamp, &maxDeviation ) );
30575 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampKHR" );
30576
30577 return detail::createResultValueType( result, std::move( data_ ) );
30578 }
30579 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
30580
30581 //=== VK_KHR_maintenance6 ===
30582
30583 // wrapper function for command vkCmdBindDescriptorSets2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorSets2KHR.html
30584 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
30585 VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorSets2KHR( const BindDescriptorSetsInfo * pBindDescriptorSetsInfo,
30586 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
30587 {
30588 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
30589 d.vkCmdBindDescriptorSets2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
30590 reinterpret_cast<const VkBindDescriptorSetsInfo *>( pBindDescriptorSetsInfo ) );
30591 }
30592
30593 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
30594 // wrapper function for command vkCmdBindDescriptorSets2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorSets2KHR.html
30595 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
30596 VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorSets2KHR( const BindDescriptorSetsInfo & bindDescriptorSetsInfo,
30597 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
30598 {
30599 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
30600 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
30601 VULKAN_HPP_ASSERT( d.vkCmdBindDescriptorSets2KHR && "Function <vkCmdBindDescriptorSets2KHR> requires <VK_KHR_maintenance6> or <VK_VERSION_1_4>" );
30602 # endif
30603
30604 d.vkCmdBindDescriptorSets2KHR( m_commandBuffer, reinterpret_cast<const VkBindDescriptorSetsInfo *>( &bindDescriptorSetsInfo ) );
30605 }
30606 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
30607
30608 // wrapper function for command vkCmdPushConstants2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushConstants2KHR.html
30609 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
30610 VULKAN_HPP_INLINE void CommandBuffer::pushConstants2KHR( const PushConstantsInfo * pPushConstantsInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
30611 {
30612 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
30613 d.vkCmdPushConstants2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkPushConstantsInfo *>( pPushConstantsInfo ) );
30614 }
30615
30616 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
30617 // wrapper function for command vkCmdPushConstants2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushConstants2KHR.html
30618 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
30619 VULKAN_HPP_INLINE void CommandBuffer::pushConstants2KHR( const PushConstantsInfo & pushConstantsInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
30620 {
30621 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
30622 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
30623 VULKAN_HPP_ASSERT( d.vkCmdPushConstants2KHR && "Function <vkCmdPushConstants2KHR> requires <VK_KHR_maintenance6> or <VK_VERSION_1_4>" );
30624 # endif
30625
30626 d.vkCmdPushConstants2KHR( m_commandBuffer, reinterpret_cast<const VkPushConstantsInfo *>( &pushConstantsInfo ) );
30627 }
30628 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
30629
30630 // wrapper function for command vkCmdPushDescriptorSet2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSet2KHR.html
30631 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
30632 VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSet2KHR( const PushDescriptorSetInfo * pPushDescriptorSetInfo,
30633 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
30634 {
30635 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
30636 d.vkCmdPushDescriptorSet2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
30637 reinterpret_cast<const VkPushDescriptorSetInfo *>( pPushDescriptorSetInfo ) );
30638 }
30639
30640 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
30641 // wrapper function for command vkCmdPushDescriptorSet2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSet2KHR.html
30642 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
30643 VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSet2KHR( const PushDescriptorSetInfo & pushDescriptorSetInfo,
30644 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
30645 {
30646 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
30647 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
30648 VULKAN_HPP_ASSERT( d.vkCmdPushDescriptorSet2KHR && "Function <vkCmdPushDescriptorSet2KHR> requires <VK_KHR_maintenance6> or <VK_VERSION_1_4>" );
30649 # endif
30650
30651 d.vkCmdPushDescriptorSet2KHR( m_commandBuffer, reinterpret_cast<const VkPushDescriptorSetInfo *>( &pushDescriptorSetInfo ) );
30652 }
30653 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
30654
30655 // wrapper function for command vkCmdPushDescriptorSetWithTemplate2KHR, see
30656 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplate2KHR.html
30657 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
30658 VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplate2KHR( const PushDescriptorSetWithTemplateInfo * pPushDescriptorSetWithTemplateInfo,
30659 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
30660 {
30661 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
30662 d.vkCmdPushDescriptorSetWithTemplate2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
30663 reinterpret_cast<const VkPushDescriptorSetWithTemplateInfo *>( pPushDescriptorSetWithTemplateInfo ) );
30664 }
30665
30666 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
30667 // wrapper function for command vkCmdPushDescriptorSetWithTemplate2KHR, see
30668 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplate2KHR.html
30669 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
30670 VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplate2KHR( const PushDescriptorSetWithTemplateInfo & pushDescriptorSetWithTemplateInfo,
30671 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
30672 {
30673 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
30674 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
30675 VULKAN_HPP_ASSERT( d.vkCmdPushDescriptorSetWithTemplate2KHR &&
30676 "Function <vkCmdPushDescriptorSetWithTemplate2KHR> requires <VK_KHR_maintenance6> or <VK_VERSION_1_4>" );
30677 # endif
30678
30679 d.vkCmdPushDescriptorSetWithTemplate2KHR( m_commandBuffer,
30680 reinterpret_cast<const VkPushDescriptorSetWithTemplateInfo *>( &pushDescriptorSetWithTemplateInfo ) );
30681 }
30682 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
30683
30684 // wrapper function for command vkCmdSetDescriptorBufferOffsets2EXT, see
30685 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDescriptorBufferOffsets2EXT.html
30686 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
30687 VULKAN_HPP_INLINE void CommandBuffer::setDescriptorBufferOffsets2EXT( const SetDescriptorBufferOffsetsInfoEXT * pSetDescriptorBufferOffsetsInfo,
30688 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
30689 {
30690 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
30691 d.vkCmdSetDescriptorBufferOffsets2EXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
30692 reinterpret_cast<const VkSetDescriptorBufferOffsetsInfoEXT *>( pSetDescriptorBufferOffsetsInfo ) );
30693 }
30694
30695 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
30696 // wrapper function for command vkCmdSetDescriptorBufferOffsets2EXT, see
30697 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDescriptorBufferOffsets2EXT.html
30698 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
30699 VULKAN_HPP_INLINE void CommandBuffer::setDescriptorBufferOffsets2EXT( const SetDescriptorBufferOffsetsInfoEXT & setDescriptorBufferOffsetsInfo,
30700 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
30701 {
30702 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
30703 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
30704 VULKAN_HPP_ASSERT( d.vkCmdSetDescriptorBufferOffsets2EXT && "Function <vkCmdSetDescriptorBufferOffsets2EXT> requires <VK_KHR_maintenance6>" );
30705 # endif
30706
30707 d.vkCmdSetDescriptorBufferOffsets2EXT( m_commandBuffer, reinterpret_cast<const VkSetDescriptorBufferOffsetsInfoEXT *>( &setDescriptorBufferOffsetsInfo ) );
30708 }
30709 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
30710
30711 // wrapper function for command vkCmdBindDescriptorBufferEmbeddedSamplers2EXT, see
30712 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorBufferEmbeddedSamplers2EXT.html
30713 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
30714 VULKAN_HPP_INLINE void
30715 CommandBuffer::bindDescriptorBufferEmbeddedSamplers2EXT( const BindDescriptorBufferEmbeddedSamplersInfoEXT * pBindDescriptorBufferEmbeddedSamplersInfo,
30716 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
30717 {
30718 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
30719 d.vkCmdBindDescriptorBufferEmbeddedSamplers2EXT(
30720 static_cast<VkCommandBuffer>( m_commandBuffer ),
30721 reinterpret_cast<const VkBindDescriptorBufferEmbeddedSamplersInfoEXT *>( pBindDescriptorBufferEmbeddedSamplersInfo ) );
30722 }
30723
30724 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
30725 // wrapper function for command vkCmdBindDescriptorBufferEmbeddedSamplers2EXT, see
30726 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorBufferEmbeddedSamplers2EXT.html
30727 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
30728 VULKAN_HPP_INLINE void
30729 CommandBuffer::bindDescriptorBufferEmbeddedSamplers2EXT( const BindDescriptorBufferEmbeddedSamplersInfoEXT & bindDescriptorBufferEmbeddedSamplersInfo,
30730 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
30731 {
30732 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
30733 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
30734 VULKAN_HPP_ASSERT( d.vkCmdBindDescriptorBufferEmbeddedSamplers2EXT &&
30735 "Function <vkCmdBindDescriptorBufferEmbeddedSamplers2EXT> requires <VK_KHR_maintenance6>" );
30736 # endif
30737
30738 d.vkCmdBindDescriptorBufferEmbeddedSamplers2EXT(
30739 m_commandBuffer, reinterpret_cast<const VkBindDescriptorBufferEmbeddedSamplersInfoEXT *>( &bindDescriptorBufferEmbeddedSamplersInfo ) );
30740 }
30741 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
30742
30743 //=== VK_QCOM_tile_memory_heap ===
30744
30745 // wrapper function for command vkCmdBindTileMemoryQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindTileMemoryQCOM.html
30746 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
30747 VULKAN_HPP_INLINE void CommandBuffer::bindTileMemoryQCOM( const TileMemoryBindInfoQCOM * pTileMemoryBindInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
30748 {
30749 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
30750 d.vkCmdBindTileMemoryQCOM( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkTileMemoryBindInfoQCOM *>( pTileMemoryBindInfo ) );
30751 }
30752
30753 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
30754 // wrapper function for command vkCmdBindTileMemoryQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindTileMemoryQCOM.html
30755 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
30756 VULKAN_HPP_INLINE void CommandBuffer::bindTileMemoryQCOM( Optional<const TileMemoryBindInfoQCOM> tileMemoryBindInfo,
30757 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
30758 {
30759 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
30760 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
30761 VULKAN_HPP_ASSERT( d.vkCmdBindTileMemoryQCOM && "Function <vkCmdBindTileMemoryQCOM> requires <VK_QCOM_tile_memory_heap>" );
30762 # endif
30763
30764 d.vkCmdBindTileMemoryQCOM( m_commandBuffer, reinterpret_cast<const VkTileMemoryBindInfoQCOM *>( tileMemoryBindInfo.get() ) );
30765 }
30766 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
30767
30768 //=== VK_KHR_copy_memory_indirect ===
30769
30770 // wrapper function for command vkCmdCopyMemoryIndirectKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryIndirectKHR.html
30771 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
30772 VULKAN_HPP_INLINE void CommandBuffer::copyMemoryIndirectKHR( const CopyMemoryIndirectInfoKHR * pCopyMemoryIndirectInfo,
30773 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
30774 {
30775 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
30776 d.vkCmdCopyMemoryIndirectKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
30777 reinterpret_cast<const VkCopyMemoryIndirectInfoKHR *>( pCopyMemoryIndirectInfo ) );
30778 }
30779
30780 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
30781 // wrapper function for command vkCmdCopyMemoryIndirectKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryIndirectKHR.html
30782 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
30783 VULKAN_HPP_INLINE void CommandBuffer::copyMemoryIndirectKHR( const CopyMemoryIndirectInfoKHR & copyMemoryIndirectInfo,
30784 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
30785 {
30786 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
30787 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
30788 VULKAN_HPP_ASSERT( d.vkCmdCopyMemoryIndirectKHR && "Function <vkCmdCopyMemoryIndirectKHR> requires <VK_KHR_copy_memory_indirect>" );
30789 # endif
30790
30791 d.vkCmdCopyMemoryIndirectKHR( m_commandBuffer, reinterpret_cast<const VkCopyMemoryIndirectInfoKHR *>( &copyMemoryIndirectInfo ) );
30792 }
30793 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
30794
30795 // wrapper function for command vkCmdCopyMemoryToImageIndirectKHR, see
30796 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToImageIndirectKHR.html
30797 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
30798 VULKAN_HPP_INLINE void CommandBuffer::copyMemoryToImageIndirectKHR( const CopyMemoryToImageIndirectInfoKHR * pCopyMemoryToImageIndirectInfo,
30799 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
30800 {
30801 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
30802 d.vkCmdCopyMemoryToImageIndirectKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
30803 reinterpret_cast<const VkCopyMemoryToImageIndirectInfoKHR *>( pCopyMemoryToImageIndirectInfo ) );
30804 }
30805
30806 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
30807 // wrapper function for command vkCmdCopyMemoryToImageIndirectKHR, see
30808 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToImageIndirectKHR.html
30809 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
30810 VULKAN_HPP_INLINE void CommandBuffer::copyMemoryToImageIndirectKHR( const CopyMemoryToImageIndirectInfoKHR & copyMemoryToImageIndirectInfo,
30811 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
30812 {
30813 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
30814 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
30815 VULKAN_HPP_ASSERT( d.vkCmdCopyMemoryToImageIndirectKHR && "Function <vkCmdCopyMemoryToImageIndirectKHR> requires <VK_KHR_copy_memory_indirect>" );
30816 # endif
30817
30818 d.vkCmdCopyMemoryToImageIndirectKHR( m_commandBuffer, reinterpret_cast<const VkCopyMemoryToImageIndirectInfoKHR *>( &copyMemoryToImageIndirectInfo ) );
30819 }
30820 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
30821
30822 //=== VK_EXT_memory_decompression ===
30823
30824 // wrapper function for command vkCmdDecompressMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecompressMemoryEXT.html
30825 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
30826 VULKAN_HPP_INLINE void CommandBuffer::decompressMemoryEXT( const DecompressMemoryInfoEXT * pDecompressMemoryInfoEXT,
30827 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
30828 {
30829 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
30830 d.vkCmdDecompressMemoryEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
30831 reinterpret_cast<const VkDecompressMemoryInfoEXT *>( pDecompressMemoryInfoEXT ) );
30832 }
30833
30834 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
30835 // wrapper function for command vkCmdDecompressMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecompressMemoryEXT.html
30836 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
30837 VULKAN_HPP_INLINE void CommandBuffer::decompressMemoryEXT( const DecompressMemoryInfoEXT & decompressMemoryInfoEXT,
30838 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
30839 {
30840 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
30841 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
30842 VULKAN_HPP_ASSERT( d.vkCmdDecompressMemoryEXT && "Function <vkCmdDecompressMemoryEXT> requires <VK_EXT_memory_decompression>" );
30843 # endif
30844
30845 d.vkCmdDecompressMemoryEXT( m_commandBuffer, reinterpret_cast<const VkDecompressMemoryInfoEXT *>( &decompressMemoryInfoEXT ) );
30846 }
30847 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
30848
30849 // wrapper function for command vkCmdDecompressMemoryIndirectCountEXT, see
30850 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecompressMemoryIndirectCountEXT.html
30851 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
30852 VULKAN_HPP_INLINE void CommandBuffer::decompressMemoryIndirectCountEXT( MemoryDecompressionMethodFlagsEXT decompressionMethod,
30853 DeviceAddress indirectCommandsAddress,
30854 DeviceAddress indirectCommandsCountAddress,
30855 uint32_t maxDecompressionCount,
30856 uint32_t stride,
30857 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
30858 {
30859 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
30860 d.vkCmdDecompressMemoryIndirectCountEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
30861 static_cast<VkMemoryDecompressionMethodFlagsEXT>( decompressionMethod ),
30862 static_cast<VkDeviceAddress>( indirectCommandsAddress ),
30863 static_cast<VkDeviceAddress>( indirectCommandsCountAddress ),
30864 maxDecompressionCount,
30865 stride );
30866 }
30867
30868 //=== VK_NV_external_compute_queue ===
30869
30870 // wrapper function for command vkCreateExternalComputeQueueNV, see
30871 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExternalComputeQueueNV.html
30872 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
30873 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createExternalComputeQueueNV( const ExternalComputeQueueCreateInfoNV * pCreateInfo,
30874 const AllocationCallbacks * pAllocator,
30875 ExternalComputeQueueNV * pExternalQueue,
30876 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
30877 {
30878 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
30879 return static_cast<Result>( d.vkCreateExternalComputeQueueNV( static_cast<VkDevice>( m_device ),
30880 reinterpret_cast<const VkExternalComputeQueueCreateInfoNV *>( pCreateInfo ),
30881 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
30882 reinterpret_cast<VkExternalComputeQueueNV *>( pExternalQueue ) ) );
30883 }
30884
30885 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
30886 // wrapper function for command vkCreateExternalComputeQueueNV, see
30887 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExternalComputeQueueNV.html
30888 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
30889 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<ExternalComputeQueueNV>::type Device::createExternalComputeQueueNV(
30890 const ExternalComputeQueueCreateInfoNV & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
30891 {
30892 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
30893 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
30894 VULKAN_HPP_ASSERT( d.vkCreateExternalComputeQueueNV && "Function <vkCreateExternalComputeQueueNV> requires <VK_NV_external_compute_queue>" );
30895 # endif
30896
30897 ExternalComputeQueueNV externalQueue;
30898 Result result = static_cast<Result>( d.vkCreateExternalComputeQueueNV( m_device,
30899 reinterpret_cast<const VkExternalComputeQueueCreateInfoNV *>( &createInfo ),
30900 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
30901 reinterpret_cast<VkExternalComputeQueueNV *>( &externalQueue ) ) );
30902 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createExternalComputeQueueNV" );
30903
30904 return detail::createResultValueType( result, std::move( externalQueue ) );
30905 }
30906
30907 # ifndef VULKAN_HPP_NO_SMART_HANDLE
30908 // wrapper function for command vkCreateExternalComputeQueueNV, see
30909 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExternalComputeQueueNV.html
30910 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
30911 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<ExternalComputeQueueNV, Dispatch>>::type
30912 Device::createExternalComputeQueueNVUnique( const ExternalComputeQueueCreateInfoNV & createInfo,
30913 Optional<const AllocationCallbacks> allocator,
30914 Dispatch const & d ) const
30915 {
30916 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
30917 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
30918 VULKAN_HPP_ASSERT( d.vkCreateExternalComputeQueueNV && "Function <vkCreateExternalComputeQueueNV> requires <VK_NV_external_compute_queue>" );
30919 # endif
30920
30921 ExternalComputeQueueNV externalQueue;
30922 Result result = static_cast<Result>( d.vkCreateExternalComputeQueueNV( m_device,
30923 reinterpret_cast<const VkExternalComputeQueueCreateInfoNV *>( &createInfo ),
30924 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
30925 reinterpret_cast<VkExternalComputeQueueNV *>( &externalQueue ) ) );
30926 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createExternalComputeQueueNVUnique" );
30927
30928 return detail::createResultValueType(
30929 result, UniqueHandle<ExternalComputeQueueNV, Dispatch>( externalQueue, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
30930 }
30931 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
30932 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
30933
30934 // wrapper function for command vkDestroyExternalComputeQueueNV, see
30935 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyExternalComputeQueueNV.html
30936 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
30937 VULKAN_HPP_INLINE void Device::destroyExternalComputeQueueNV( ExternalComputeQueueNV externalQueue,
30938 const AllocationCallbacks * pAllocator,
30939 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
30940 {
30941 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
30942 d.vkDestroyExternalComputeQueueNV( static_cast<VkDevice>( m_device ),
30943 static_cast<VkExternalComputeQueueNV>( externalQueue ),
30944 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
30945 }
30946
30947 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
30948 // wrapper function for command vkDestroyExternalComputeQueueNV, see
30949 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyExternalComputeQueueNV.html
30950 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
30951 VULKAN_HPP_INLINE void Device::destroyExternalComputeQueueNV( ExternalComputeQueueNV externalQueue,
30952 Optional<const AllocationCallbacks> allocator,
30953 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
30954 {
30955 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
30956 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
30957 VULKAN_HPP_ASSERT( d.vkDestroyExternalComputeQueueNV && "Function <vkDestroyExternalComputeQueueNV> requires <VK_NV_external_compute_queue>" );
30958 # endif
30959
30960 d.vkDestroyExternalComputeQueueNV(
30961 m_device, static_cast<VkExternalComputeQueueNV>( externalQueue ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
30962 }
30963 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
30964
30965 // wrapper function for command vkDestroyExternalComputeQueueNV, see
30966 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyExternalComputeQueueNV.html
30967 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
30968 VULKAN_HPP_INLINE void
30969 Device::destroy( ExternalComputeQueueNV externalQueue, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
30970 {
30971 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
30972 d.vkDestroyExternalComputeQueueNV( static_cast<VkDevice>( m_device ),
30973 static_cast<VkExternalComputeQueueNV>( externalQueue ),
30974 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
30975 }
30976
30977 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
30978 // wrapper function for command vkDestroyExternalComputeQueueNV, see
30979 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyExternalComputeQueueNV.html
30980 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
30981 VULKAN_HPP_INLINE void
30982 Device::destroy( ExternalComputeQueueNV externalQueue, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
30983 {
30984 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
30985 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
30986 VULKAN_HPP_ASSERT( d.vkDestroyExternalComputeQueueNV && "Function <vkDestroyExternalComputeQueueNV> requires <VK_NV_external_compute_queue>" );
30987 # endif
30988
30989 d.vkDestroyExternalComputeQueueNV(
30990 m_device, static_cast<VkExternalComputeQueueNV>( externalQueue ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
30991 }
30992 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
30993
30994 // wrapper function for command vkGetExternalComputeQueueDataNV, see
30995 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExternalComputeQueueDataNV.html
30996 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
30997 VULKAN_HPP_INLINE void
30998 ExternalComputeQueueNV::getData( ExternalComputeQueueDataParamsNV * params, void * pData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
30999 {
31000 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
31001 d.vkGetExternalComputeQueueDataNV(
31002 static_cast<VkExternalComputeQueueNV>( m_externalComputeQueueNV ), reinterpret_cast<VkExternalComputeQueueDataParamsNV *>( params ), pData );
31003 }
31004
31005 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
31006 // wrapper function for command vkGetExternalComputeQueueDataNV, see
31007 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExternalComputeQueueDataNV.html
31008 template <typename DataType, typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
31009 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<ExternalComputeQueueDataParamsNV, DataType>
31010 ExternalComputeQueueNV::getData( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
31011 {
31012 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
31013 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
31014 VULKAN_HPP_ASSERT( d.vkGetExternalComputeQueueDataNV && "Function <vkGetExternalComputeQueueDataNV> requires <VK_NV_external_compute_queue>" );
31015 # endif
31016
31017 std::pair<ExternalComputeQueueDataParamsNV, DataType> data_;
31018 ExternalComputeQueueDataParamsNV & arams = data_.first;
31019 DataType & data = data_.second;
31020 d.vkGetExternalComputeQueueDataNV( m_externalComputeQueueNV, reinterpret_cast<VkExternalComputeQueueDataParamsNV *>( &arams ), &data );
31021
31022 return data_;
31023 }
31024 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
31025
31026 //=== VK_NV_cluster_acceleration_structure ===
31027
31028 // wrapper function for command vkGetClusterAccelerationStructureBuildSizesNV, see
31029 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetClusterAccelerationStructureBuildSizesNV.html
31030 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
31031 VULKAN_HPP_INLINE void Device::getClusterAccelerationStructureBuildSizesNV( const ClusterAccelerationStructureInputInfoNV * pInfo,
31032 AccelerationStructureBuildSizesInfoKHR * pSizeInfo,
31033 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
31034 {
31035 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
31036 d.vkGetClusterAccelerationStructureBuildSizesNV( static_cast<VkDevice>( m_device ),
31037 reinterpret_cast<const VkClusterAccelerationStructureInputInfoNV *>( pInfo ),
31038 reinterpret_cast<VkAccelerationStructureBuildSizesInfoKHR *>( pSizeInfo ) );
31039 }
31040
31041 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
31042 // wrapper function for command vkGetClusterAccelerationStructureBuildSizesNV, see
31043 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetClusterAccelerationStructureBuildSizesNV.html
31044 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
31045 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE AccelerationStructureBuildSizesInfoKHR
31046 Device::getClusterAccelerationStructureBuildSizesNV( const ClusterAccelerationStructureInputInfoNV & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
31047 {
31048 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
31049 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
31050 VULKAN_HPP_ASSERT( d.vkGetClusterAccelerationStructureBuildSizesNV &&
31051 "Function <vkGetClusterAccelerationStructureBuildSizesNV> requires <VK_NV_cluster_acceleration_structure>" );
31052 # endif
31053
31054 AccelerationStructureBuildSizesInfoKHR sizeInfo;
31055 d.vkGetClusterAccelerationStructureBuildSizesNV( m_device,
31056 reinterpret_cast<const VkClusterAccelerationStructureInputInfoNV *>( &info ),
31057 reinterpret_cast<VkAccelerationStructureBuildSizesInfoKHR *>( &sizeInfo ) );
31058
31059 return sizeInfo;
31060 }
31061 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
31062
31063 // wrapper function for command vkCmdBuildClusterAccelerationStructureIndirectNV, see
31064 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildClusterAccelerationStructureIndirectNV.html
31065 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
31066 VULKAN_HPP_INLINE void CommandBuffer::buildClusterAccelerationStructureIndirectNV( const ClusterAccelerationStructureCommandsInfoNV * pCommandInfos,
31067 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
31068 {
31069 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
31070 d.vkCmdBuildClusterAccelerationStructureIndirectNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
31071 reinterpret_cast<const VkClusterAccelerationStructureCommandsInfoNV *>( pCommandInfos ) );
31072 }
31073
31074 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
31075 // wrapper function for command vkCmdBuildClusterAccelerationStructureIndirectNV, see
31076 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildClusterAccelerationStructureIndirectNV.html
31077 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
31078 VULKAN_HPP_INLINE void CommandBuffer::buildClusterAccelerationStructureIndirectNV( const ClusterAccelerationStructureCommandsInfoNV & commandInfos,
31079 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
31080 {
31081 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
31082 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
31083 VULKAN_HPP_ASSERT( d.vkCmdBuildClusterAccelerationStructureIndirectNV &&
31084 "Function <vkCmdBuildClusterAccelerationStructureIndirectNV> requires <VK_NV_cluster_acceleration_structure>" );
31085 # endif
31086
31087 d.vkCmdBuildClusterAccelerationStructureIndirectNV( m_commandBuffer,
31088 reinterpret_cast<const VkClusterAccelerationStructureCommandsInfoNV *>( &commandInfos ) );
31089 }
31090 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
31091
31092 //=== VK_NV_partitioned_acceleration_structure ===
31093
31094 // wrapper function for command vkGetPartitionedAccelerationStructuresBuildSizesNV, see
31095 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPartitionedAccelerationStructuresBuildSizesNV.html
31096 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
31097 VULKAN_HPP_INLINE void Device::getPartitionedAccelerationStructuresBuildSizesNV( const PartitionedAccelerationStructureInstancesInputNV * pInfo,
31098 AccelerationStructureBuildSizesInfoKHR * pSizeInfo,
31099 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
31100 {
31101 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
31102 d.vkGetPartitionedAccelerationStructuresBuildSizesNV( static_cast<VkDevice>( m_device ),
31103 reinterpret_cast<const VkPartitionedAccelerationStructureInstancesInputNV *>( pInfo ),
31104 reinterpret_cast<VkAccelerationStructureBuildSizesInfoKHR *>( pSizeInfo ) );
31105 }
31106
31107 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
31108 // wrapper function for command vkGetPartitionedAccelerationStructuresBuildSizesNV, see
31109 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPartitionedAccelerationStructuresBuildSizesNV.html
31110 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
31111 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE AccelerationStructureBuildSizesInfoKHR Device::getPartitionedAccelerationStructuresBuildSizesNV(
31112 const PartitionedAccelerationStructureInstancesInputNV & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
31113 {
31114 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
31115 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
31116 VULKAN_HPP_ASSERT( d.vkGetPartitionedAccelerationStructuresBuildSizesNV &&
31117 "Function <vkGetPartitionedAccelerationStructuresBuildSizesNV> requires <VK_NV_partitioned_acceleration_structure>" );
31118 # endif
31119
31120 AccelerationStructureBuildSizesInfoKHR sizeInfo;
31121 d.vkGetPartitionedAccelerationStructuresBuildSizesNV( m_device,
31122 reinterpret_cast<const VkPartitionedAccelerationStructureInstancesInputNV *>( &info ),
31123 reinterpret_cast<VkAccelerationStructureBuildSizesInfoKHR *>( &sizeInfo ) );
31124
31125 return sizeInfo;
31126 }
31127 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
31128
31129 // wrapper function for command vkCmdBuildPartitionedAccelerationStructuresNV, see
31130 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildPartitionedAccelerationStructuresNV.html
31131 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
31132 VULKAN_HPP_INLINE void CommandBuffer::buildPartitionedAccelerationStructuresNV( const BuildPartitionedAccelerationStructureInfoNV * pBuildInfo,
31133 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
31134 {
31135 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
31136 d.vkCmdBuildPartitionedAccelerationStructuresNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
31137 reinterpret_cast<const VkBuildPartitionedAccelerationStructureInfoNV *>( pBuildInfo ) );
31138 }
31139
31140 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
31141 // wrapper function for command vkCmdBuildPartitionedAccelerationStructuresNV, see
31142 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildPartitionedAccelerationStructuresNV.html
31143 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
31144 VULKAN_HPP_INLINE void CommandBuffer::buildPartitionedAccelerationStructuresNV( const BuildPartitionedAccelerationStructureInfoNV & buildInfo,
31145 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
31146 {
31147 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
31148 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
31149 VULKAN_HPP_ASSERT( d.vkCmdBuildPartitionedAccelerationStructuresNV &&
31150 "Function <vkCmdBuildPartitionedAccelerationStructuresNV> requires <VK_NV_partitioned_acceleration_structure>" );
31151 # endif
31152
31153 d.vkCmdBuildPartitionedAccelerationStructuresNV( m_commandBuffer, reinterpret_cast<const VkBuildPartitionedAccelerationStructureInfoNV *>( &buildInfo ) );
31154 }
31155 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
31156
31157 //=== VK_EXT_device_generated_commands ===
31158
31159 // wrapper function for command vkGetGeneratedCommandsMemoryRequirementsEXT, see
31160 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGeneratedCommandsMemoryRequirementsEXT.html
31161 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
31162 VULKAN_HPP_INLINE void Device::getGeneratedCommandsMemoryRequirementsEXT( const GeneratedCommandsMemoryRequirementsInfoEXT * pInfo,
31163 MemoryRequirements2 * pMemoryRequirements,
31164 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
31165 {
31166 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
31167 d.vkGetGeneratedCommandsMemoryRequirementsEXT( static_cast<VkDevice>( m_device ),
31168 reinterpret_cast<const VkGeneratedCommandsMemoryRequirementsInfoEXT *>( pInfo ),
31169 reinterpret_cast<VkMemoryRequirements2 *>( pMemoryRequirements ) );
31170 }
31171
31172 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
31173 // wrapper function for command vkGetGeneratedCommandsMemoryRequirementsEXT, see
31174 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGeneratedCommandsMemoryRequirementsEXT.html
31175 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
31176 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2
31177 Device::getGeneratedCommandsMemoryRequirementsEXT( const GeneratedCommandsMemoryRequirementsInfoEXT & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
31178 {
31179 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
31180 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
31181 VULKAN_HPP_ASSERT( d.vkGetGeneratedCommandsMemoryRequirementsEXT &&
31182 "Function <vkGetGeneratedCommandsMemoryRequirementsEXT> requires <VK_EXT_device_generated_commands>" );
31183 # endif
31184
31185 MemoryRequirements2 memoryRequirements;
31186 d.vkGetGeneratedCommandsMemoryRequirementsEXT( m_device,
31187 reinterpret_cast<const VkGeneratedCommandsMemoryRequirementsInfoEXT *>( &info ),
31188 reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
31189
31190 return memoryRequirements;
31191 }
31192
31193 // wrapper function for command vkGetGeneratedCommandsMemoryRequirementsEXT, see
31194 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGeneratedCommandsMemoryRequirementsEXT.html
31195 template <typename X, typename Y, typename... Z, typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
31196 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...>
31197 Device::getGeneratedCommandsMemoryRequirementsEXT( const GeneratedCommandsMemoryRequirementsInfoEXT & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
31198 {
31199 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
31200 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
31201 VULKAN_HPP_ASSERT( d.vkGetGeneratedCommandsMemoryRequirementsEXT &&
31202 "Function <vkGetGeneratedCommandsMemoryRequirementsEXT> requires <VK_EXT_device_generated_commands>" );
31203 # endif
31204
31205 StructureChain<X, Y, Z...> structureChain;
31206 MemoryRequirements2 & memoryRequirements = structureChain.template get<MemoryRequirements2>();
31207 d.vkGetGeneratedCommandsMemoryRequirementsEXT( m_device,
31208 reinterpret_cast<const VkGeneratedCommandsMemoryRequirementsInfoEXT *>( &info ),
31209 reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
31210
31211 return structureChain;
31212 }
31213 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
31214
31215 // wrapper function for command vkCmdPreprocessGeneratedCommandsEXT, see
31216 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPreprocessGeneratedCommandsEXT.html
31217 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
31218 VULKAN_HPP_INLINE void CommandBuffer::preprocessGeneratedCommandsEXT( const GeneratedCommandsInfoEXT * pGeneratedCommandsInfo,
31219 CommandBuffer stateCommandBuffer,
31220 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
31221 {
31222 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
31223 d.vkCmdPreprocessGeneratedCommandsEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
31224 reinterpret_cast<const VkGeneratedCommandsInfoEXT *>( pGeneratedCommandsInfo ),
31225 static_cast<VkCommandBuffer>( stateCommandBuffer ) );
31226 }
31227
31228 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
31229 // wrapper function for command vkCmdPreprocessGeneratedCommandsEXT, see
31230 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPreprocessGeneratedCommandsEXT.html
31231 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
31232 VULKAN_HPP_INLINE void CommandBuffer::preprocessGeneratedCommandsEXT( const GeneratedCommandsInfoEXT & generatedCommandsInfo,
31233 CommandBuffer stateCommandBuffer,
31234 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
31235 {
31236 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
31237 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
31238 VULKAN_HPP_ASSERT( d.vkCmdPreprocessGeneratedCommandsEXT && "Function <vkCmdPreprocessGeneratedCommandsEXT> requires <VK_EXT_device_generated_commands>" );
31239 # endif
31240
31241 d.vkCmdPreprocessGeneratedCommandsEXT(
31242 m_commandBuffer, reinterpret_cast<const VkGeneratedCommandsInfoEXT *>( &generatedCommandsInfo ), static_cast<VkCommandBuffer>( stateCommandBuffer ) );
31243 }
31244 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
31245
31246 // wrapper function for command vkCmdExecuteGeneratedCommandsEXT, see
31247 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdExecuteGeneratedCommandsEXT.html
31248 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
31249 VULKAN_HPP_INLINE void CommandBuffer::executeGeneratedCommandsEXT( Bool32 isPreprocessed,
31250 const GeneratedCommandsInfoEXT * pGeneratedCommandsInfo,
31251 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
31252 {
31253 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
31254 d.vkCmdExecuteGeneratedCommandsEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
31255 static_cast<VkBool32>( isPreprocessed ),
31256 reinterpret_cast<const VkGeneratedCommandsInfoEXT *>( pGeneratedCommandsInfo ) );
31257 }
31258
31259 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
31260 // wrapper function for command vkCmdExecuteGeneratedCommandsEXT, see
31261 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdExecuteGeneratedCommandsEXT.html
31262 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
31263 VULKAN_HPP_INLINE void CommandBuffer::executeGeneratedCommandsEXT( Bool32 isPreprocessed,
31264 const GeneratedCommandsInfoEXT & generatedCommandsInfo,
31265 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
31266 {
31267 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
31268 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
31269 VULKAN_HPP_ASSERT( d.vkCmdExecuteGeneratedCommandsEXT && "Function <vkCmdExecuteGeneratedCommandsEXT> requires <VK_EXT_device_generated_commands>" );
31270 # endif
31271
31272 d.vkCmdExecuteGeneratedCommandsEXT(
31273 m_commandBuffer, static_cast<VkBool32>( isPreprocessed ), reinterpret_cast<const VkGeneratedCommandsInfoEXT *>( &generatedCommandsInfo ) );
31274 }
31275 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
31276
31277 // wrapper function for command vkCreateIndirectCommandsLayoutEXT, see
31278 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectCommandsLayoutEXT.html
31279 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
31280 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createIndirectCommandsLayoutEXT( const IndirectCommandsLayoutCreateInfoEXT * pCreateInfo,
31281 const AllocationCallbacks * pAllocator,
31282 IndirectCommandsLayoutEXT * pIndirectCommandsLayout,
31283 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
31284 {
31285 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
31286 return static_cast<Result>( d.vkCreateIndirectCommandsLayoutEXT( static_cast<VkDevice>( m_device ),
31287 reinterpret_cast<const VkIndirectCommandsLayoutCreateInfoEXT *>( pCreateInfo ),
31288 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
31289 reinterpret_cast<VkIndirectCommandsLayoutEXT *>( pIndirectCommandsLayout ) ) );
31290 }
31291
31292 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
31293 // wrapper function for command vkCreateIndirectCommandsLayoutEXT, see
31294 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectCommandsLayoutEXT.html
31295 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
31296 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<IndirectCommandsLayoutEXT>::type Device::createIndirectCommandsLayoutEXT(
31297 const IndirectCommandsLayoutCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
31298 {
31299 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
31300 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
31301 VULKAN_HPP_ASSERT( d.vkCreateIndirectCommandsLayoutEXT && "Function <vkCreateIndirectCommandsLayoutEXT> requires <VK_EXT_device_generated_commands>" );
31302 # endif
31303
31304 IndirectCommandsLayoutEXT indirectCommandsLayout;
31305 Result result = static_cast<Result>( d.vkCreateIndirectCommandsLayoutEXT( m_device,
31306 reinterpret_cast<const VkIndirectCommandsLayoutCreateInfoEXT *>( &createInfo ),
31307 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
31308 reinterpret_cast<VkIndirectCommandsLayoutEXT *>( &indirectCommandsLayout ) ) );
31309 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createIndirectCommandsLayoutEXT" );
31310
31311 return detail::createResultValueType( result, std::move( indirectCommandsLayout ) );
31312 }
31313
31314 # ifndef VULKAN_HPP_NO_SMART_HANDLE
31315 // wrapper function for command vkCreateIndirectCommandsLayoutEXT, see
31316 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectCommandsLayoutEXT.html
31317 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
31318 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<IndirectCommandsLayoutEXT, Dispatch>>::type
31319 Device::createIndirectCommandsLayoutEXTUnique( const IndirectCommandsLayoutCreateInfoEXT & createInfo,
31320 Optional<const AllocationCallbacks> allocator,
31321 Dispatch const & d ) const
31322 {
31323 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
31324 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
31325 VULKAN_HPP_ASSERT( d.vkCreateIndirectCommandsLayoutEXT && "Function <vkCreateIndirectCommandsLayoutEXT> requires <VK_EXT_device_generated_commands>" );
31326 # endif
31327
31328 IndirectCommandsLayoutEXT indirectCommandsLayout;
31329 Result result = static_cast<Result>( d.vkCreateIndirectCommandsLayoutEXT( m_device,
31330 reinterpret_cast<const VkIndirectCommandsLayoutCreateInfoEXT *>( &createInfo ),
31331 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
31332 reinterpret_cast<VkIndirectCommandsLayoutEXT *>( &indirectCommandsLayout ) ) );
31333 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createIndirectCommandsLayoutEXTUnique" );
31334
31335 return detail::createResultValueType(
31336 result, UniqueHandle<IndirectCommandsLayoutEXT, Dispatch>( indirectCommandsLayout, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
31337 }
31338 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
31339 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
31340
31341 // wrapper function for command vkDestroyIndirectCommandsLayoutEXT, see
31342 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectCommandsLayoutEXT.html
31343 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
31344 VULKAN_HPP_INLINE void Device::destroyIndirectCommandsLayoutEXT( IndirectCommandsLayoutEXT indirectCommandsLayout,
31345 const AllocationCallbacks * pAllocator,
31346 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
31347 {
31348 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
31349 d.vkDestroyIndirectCommandsLayoutEXT( static_cast<VkDevice>( m_device ),
31350 static_cast<VkIndirectCommandsLayoutEXT>( indirectCommandsLayout ),
31351 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
31352 }
31353
31354 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
31355 // wrapper function for command vkDestroyIndirectCommandsLayoutEXT, see
31356 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectCommandsLayoutEXT.html
31357 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
31358 VULKAN_HPP_INLINE void Device::destroyIndirectCommandsLayoutEXT( IndirectCommandsLayoutEXT indirectCommandsLayout,
31359 Optional<const AllocationCallbacks> allocator,
31360 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
31361 {
31362 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
31363 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
31364 VULKAN_HPP_ASSERT( d.vkDestroyIndirectCommandsLayoutEXT && "Function <vkDestroyIndirectCommandsLayoutEXT> requires <VK_EXT_device_generated_commands>" );
31365 # endif
31366
31367 d.vkDestroyIndirectCommandsLayoutEXT(
31368 m_device, static_cast<VkIndirectCommandsLayoutEXT>( indirectCommandsLayout ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
31369 }
31370 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
31371
31372 // wrapper function for command vkDestroyIndirectCommandsLayoutEXT, see
31373 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectCommandsLayoutEXT.html
31374 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
31375 VULKAN_HPP_INLINE void
31376 Device::destroy( IndirectCommandsLayoutEXT indirectCommandsLayout, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
31377 {
31378 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
31379 d.vkDestroyIndirectCommandsLayoutEXT( static_cast<VkDevice>( m_device ),
31380 static_cast<VkIndirectCommandsLayoutEXT>( indirectCommandsLayout ),
31381 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
31382 }
31383
31384 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
31385 // wrapper function for command vkDestroyIndirectCommandsLayoutEXT, see
31386 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectCommandsLayoutEXT.html
31387 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
31388 VULKAN_HPP_INLINE void Device::destroy( IndirectCommandsLayoutEXT indirectCommandsLayout,
31389 Optional<const AllocationCallbacks> allocator,
31390 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
31391 {
31392 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
31393 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
31394 VULKAN_HPP_ASSERT( d.vkDestroyIndirectCommandsLayoutEXT && "Function <vkDestroyIndirectCommandsLayoutEXT> requires <VK_EXT_device_generated_commands>" );
31395 # endif
31396
31397 d.vkDestroyIndirectCommandsLayoutEXT(
31398 m_device, static_cast<VkIndirectCommandsLayoutEXT>( indirectCommandsLayout ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
31399 }
31400 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
31401
31402 // wrapper function for command vkCreateIndirectExecutionSetEXT, see
31403 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectExecutionSetEXT.html
31404 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
31405 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createIndirectExecutionSetEXT( const IndirectExecutionSetCreateInfoEXT * pCreateInfo,
31406 const AllocationCallbacks * pAllocator,
31407 IndirectExecutionSetEXT * pIndirectExecutionSet,
31408 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
31409 {
31410 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
31411 return static_cast<Result>( d.vkCreateIndirectExecutionSetEXT( static_cast<VkDevice>( m_device ),
31412 reinterpret_cast<const VkIndirectExecutionSetCreateInfoEXT *>( pCreateInfo ),
31413 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
31414 reinterpret_cast<VkIndirectExecutionSetEXT *>( pIndirectExecutionSet ) ) );
31415 }
31416
31417 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
31418 // wrapper function for command vkCreateIndirectExecutionSetEXT, see
31419 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectExecutionSetEXT.html
31420 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
31421 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<IndirectExecutionSetEXT>::type Device::createIndirectExecutionSetEXT(
31422 const IndirectExecutionSetCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
31423 {
31424 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
31425 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
31426 VULKAN_HPP_ASSERT( d.vkCreateIndirectExecutionSetEXT && "Function <vkCreateIndirectExecutionSetEXT> requires <VK_EXT_device_generated_commands>" );
31427 # endif
31428
31429 IndirectExecutionSetEXT indirectExecutionSet;
31430 Result result = static_cast<Result>( d.vkCreateIndirectExecutionSetEXT( m_device,
31431 reinterpret_cast<const VkIndirectExecutionSetCreateInfoEXT *>( &createInfo ),
31432 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
31433 reinterpret_cast<VkIndirectExecutionSetEXT *>( &indirectExecutionSet ) ) );
31434 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createIndirectExecutionSetEXT" );
31435
31436 return detail::createResultValueType( result, std::move( indirectExecutionSet ) );
31437 }
31438
31439 # ifndef VULKAN_HPP_NO_SMART_HANDLE
31440 // wrapper function for command vkCreateIndirectExecutionSetEXT, see
31441 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectExecutionSetEXT.html
31442 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
31443 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<IndirectExecutionSetEXT, Dispatch>>::type
31444 Device::createIndirectExecutionSetEXTUnique( const IndirectExecutionSetCreateInfoEXT & createInfo,
31445 Optional<const AllocationCallbacks> allocator,
31446 Dispatch const & d ) const
31447 {
31448 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
31449 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
31450 VULKAN_HPP_ASSERT( d.vkCreateIndirectExecutionSetEXT && "Function <vkCreateIndirectExecutionSetEXT> requires <VK_EXT_device_generated_commands>" );
31451 # endif
31452
31453 IndirectExecutionSetEXT indirectExecutionSet;
31454 Result result = static_cast<Result>( d.vkCreateIndirectExecutionSetEXT( m_device,
31455 reinterpret_cast<const VkIndirectExecutionSetCreateInfoEXT *>( &createInfo ),
31456 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
31457 reinterpret_cast<VkIndirectExecutionSetEXT *>( &indirectExecutionSet ) ) );
31458 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createIndirectExecutionSetEXTUnique" );
31459
31460 return detail::createResultValueType(
31461 result, UniqueHandle<IndirectExecutionSetEXT, Dispatch>( indirectExecutionSet, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
31462 }
31463 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
31464 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
31465
31466 // wrapper function for command vkDestroyIndirectExecutionSetEXT, see
31467 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectExecutionSetEXT.html
31468 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
31469 VULKAN_HPP_INLINE void Device::destroyIndirectExecutionSetEXT( IndirectExecutionSetEXT indirectExecutionSet,
31470 const AllocationCallbacks * pAllocator,
31471 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
31472 {
31473 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
31474 d.vkDestroyIndirectExecutionSetEXT( static_cast<VkDevice>( m_device ),
31475 static_cast<VkIndirectExecutionSetEXT>( indirectExecutionSet ),
31476 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
31477 }
31478
31479 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
31480 // wrapper function for command vkDestroyIndirectExecutionSetEXT, see
31481 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectExecutionSetEXT.html
31482 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
31483 VULKAN_HPP_INLINE void Device::destroyIndirectExecutionSetEXT( IndirectExecutionSetEXT indirectExecutionSet,
31484 Optional<const AllocationCallbacks> allocator,
31485 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
31486 {
31487 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
31488 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
31489 VULKAN_HPP_ASSERT( d.vkDestroyIndirectExecutionSetEXT && "Function <vkDestroyIndirectExecutionSetEXT> requires <VK_EXT_device_generated_commands>" );
31490 # endif
31491
31492 d.vkDestroyIndirectExecutionSetEXT(
31493 m_device, static_cast<VkIndirectExecutionSetEXT>( indirectExecutionSet ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
31494 }
31495 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
31496
31497 // wrapper function for command vkDestroyIndirectExecutionSetEXT, see
31498 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectExecutionSetEXT.html
31499 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
31500 VULKAN_HPP_INLINE void
31501 Device::destroy( IndirectExecutionSetEXT indirectExecutionSet, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
31502 {
31503 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
31504 d.vkDestroyIndirectExecutionSetEXT( static_cast<VkDevice>( m_device ),
31505 static_cast<VkIndirectExecutionSetEXT>( indirectExecutionSet ),
31506 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
31507 }
31508
31509 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
31510 // wrapper function for command vkDestroyIndirectExecutionSetEXT, see
31511 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectExecutionSetEXT.html
31512 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
31513 VULKAN_HPP_INLINE void
31514 Device::destroy( IndirectExecutionSetEXT indirectExecutionSet, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
31515 {
31516 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
31517 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
31518 VULKAN_HPP_ASSERT( d.vkDestroyIndirectExecutionSetEXT && "Function <vkDestroyIndirectExecutionSetEXT> requires <VK_EXT_device_generated_commands>" );
31519 # endif
31520
31521 d.vkDestroyIndirectExecutionSetEXT(
31522 m_device, static_cast<VkIndirectExecutionSetEXT>( indirectExecutionSet ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) );
31523 }
31524 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
31525
31526 // wrapper function for command vkUpdateIndirectExecutionSetPipelineEXT, see
31527 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateIndirectExecutionSetPipelineEXT.html
31528 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
31529 VULKAN_HPP_INLINE void Device::updateIndirectExecutionSetPipelineEXT( IndirectExecutionSetEXT indirectExecutionSet,
31530 uint32_t executionSetWriteCount,
31531 const WriteIndirectExecutionSetPipelineEXT * pExecutionSetWrites,
31532 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
31533 {
31534 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
31535 d.vkUpdateIndirectExecutionSetPipelineEXT( static_cast<VkDevice>( m_device ),
31536 static_cast<VkIndirectExecutionSetEXT>( indirectExecutionSet ),
31537 executionSetWriteCount,
31538 reinterpret_cast<const VkWriteIndirectExecutionSetPipelineEXT *>( pExecutionSetWrites ) );
31539 }
31540
31541 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
31542 // wrapper function for command vkUpdateIndirectExecutionSetPipelineEXT, see
31543 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateIndirectExecutionSetPipelineEXT.html
31544 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
31545 VULKAN_HPP_INLINE void Device::updateIndirectExecutionSetPipelineEXT( IndirectExecutionSetEXT indirectExecutionSet,
31546 ArrayProxy<const WriteIndirectExecutionSetPipelineEXT> const & executionSetWrites,
31547 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
31548 {
31549 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
31550 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
31551 VULKAN_HPP_ASSERT( d.vkUpdateIndirectExecutionSetPipelineEXT &&
31552 "Function <vkUpdateIndirectExecutionSetPipelineEXT> requires <VK_EXT_device_generated_commands>" );
31553 # endif
31554
31555 d.vkUpdateIndirectExecutionSetPipelineEXT( m_device,
31556 static_cast<VkIndirectExecutionSetEXT>( indirectExecutionSet ),
31557 executionSetWrites.size(),
31558 reinterpret_cast<const VkWriteIndirectExecutionSetPipelineEXT *>( executionSetWrites.data() ) );
31559 }
31560 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
31561
31562 // wrapper function for command vkUpdateIndirectExecutionSetShaderEXT, see
31563 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateIndirectExecutionSetShaderEXT.html
31564 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
31565 VULKAN_HPP_INLINE void Device::updateIndirectExecutionSetShaderEXT( IndirectExecutionSetEXT indirectExecutionSet,
31566 uint32_t executionSetWriteCount,
31567 const WriteIndirectExecutionSetShaderEXT * pExecutionSetWrites,
31568 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
31569 {
31570 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
31571 d.vkUpdateIndirectExecutionSetShaderEXT( static_cast<VkDevice>( m_device ),
31572 static_cast<VkIndirectExecutionSetEXT>( indirectExecutionSet ),
31573 executionSetWriteCount,
31574 reinterpret_cast<const VkWriteIndirectExecutionSetShaderEXT *>( pExecutionSetWrites ) );
31575 }
31576
31577 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
31578 // wrapper function for command vkUpdateIndirectExecutionSetShaderEXT, see
31579 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateIndirectExecutionSetShaderEXT.html
31580 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
31581 VULKAN_HPP_INLINE void Device::updateIndirectExecutionSetShaderEXT( IndirectExecutionSetEXT indirectExecutionSet,
31582 ArrayProxy<const WriteIndirectExecutionSetShaderEXT> const & executionSetWrites,
31583 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
31584 {
31585 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
31586 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
31587 VULKAN_HPP_ASSERT( d.vkUpdateIndirectExecutionSetShaderEXT &&
31588 "Function <vkUpdateIndirectExecutionSetShaderEXT> requires <VK_EXT_device_generated_commands>" );
31589 # endif
31590
31591 d.vkUpdateIndirectExecutionSetShaderEXT( m_device,
31592 static_cast<VkIndirectExecutionSetEXT>( indirectExecutionSet ),
31593 executionSetWrites.size(),
31594 reinterpret_cast<const VkWriteIndirectExecutionSetShaderEXT *>( executionSetWrites.data() ) );
31595 }
31596 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
31597
31598 #if defined( VK_USE_PLATFORM_OHOS )
31599 //=== VK_OHOS_surface ===
31600
31601 // wrapper function for command vkCreateSurfaceOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSurfaceOHOS.html
31602 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
31603 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createSurfaceOHOS( const SurfaceCreateInfoOHOS * pCreateInfo,
31604 const AllocationCallbacks * pAllocator,
31605 SurfaceKHR * pSurface,
31606 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
31607 {
31608 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
31609 return static_cast<Result>( d.vkCreateSurfaceOHOS( static_cast<VkInstance>( m_instance ),
31610 reinterpret_cast<const VkSurfaceCreateInfoOHOS *>( pCreateInfo ),
31611 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
31612 reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) );
31613 }
31614
31615 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
31616 // wrapper function for command vkCreateSurfaceOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSurfaceOHOS.html
31617 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
31618 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<SurfaceKHR>::type
31619 Instance::createSurfaceOHOS( const SurfaceCreateInfoOHOS & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
31620 {
31621 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
31622 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
31623 VULKAN_HPP_ASSERT( d.vkCreateSurfaceOHOS && "Function <vkCreateSurfaceOHOS> requires <VK_OHOS_surface>" );
31624 # endif
31625
31626 SurfaceKHR surface;
31627 Result result = static_cast<Result>( d.vkCreateSurfaceOHOS( m_instance,
31628 reinterpret_cast<const VkSurfaceCreateInfoOHOS *>( &createInfo ),
31629 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
31630 reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
31631 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createSurfaceOHOS" );
31632
31633 return detail::createResultValueType( result, std::move( surface ) );
31634 }
31635
31636 # ifndef VULKAN_HPP_NO_SMART_HANDLE
31637 // wrapper function for command vkCreateSurfaceOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSurfaceOHOS.html
31638 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
31639 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
31640 Instance::createSurfaceOHOSUnique( const SurfaceCreateInfoOHOS & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
31641 {
31642 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
31643 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
31644 VULKAN_HPP_ASSERT( d.vkCreateSurfaceOHOS && "Function <vkCreateSurfaceOHOS> requires <VK_OHOS_surface>" );
31645 # endif
31646
31647 SurfaceKHR surface;
31648 Result result = static_cast<Result>( d.vkCreateSurfaceOHOS( m_instance,
31649 reinterpret_cast<const VkSurfaceCreateInfoOHOS *>( &createInfo ),
31650 reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ),
31651 reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
31652 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createSurfaceOHOSUnique" );
31653
31654 return detail::createResultValueType( result,
31655 UniqueHandle<SurfaceKHR, Dispatch>( surface, detail::ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) );
31656 }
31657 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
31658 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
31659 #endif /*VK_USE_PLATFORM_OHOS*/
31660
31661 #if defined( VK_USE_PLATFORM_OHOS )
31662 //=== VK_OHOS_native_buffer ===
31663
31664 // wrapper function for command vkGetSwapchainGrallocUsageOHOS, see
31665 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainGrallocUsageOHOS.html
31666 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
31667 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
31668 Device::getSwapchainGrallocUsageOHOS( Format format, ImageUsageFlags imageUsage, uint64_t * grallocUsage, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
31669 {
31670 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
31671 return static_cast<Result>( d.vkGetSwapchainGrallocUsageOHOS(
31672 static_cast<VkDevice>( m_device ), static_cast<VkFormat>( format ), static_cast<VkImageUsageFlags>( imageUsage ), grallocUsage ) );
31673 }
31674
31675 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
31676 // wrapper function for command vkGetSwapchainGrallocUsageOHOS, see
31677 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainGrallocUsageOHOS.html
31678 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
31679 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<uint64_t>::type
31680 Device::getSwapchainGrallocUsageOHOS( Format format, ImageUsageFlags imageUsage, Dispatch const & d ) const
31681 {
31682 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
31683 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
31684 VULKAN_HPP_ASSERT( d.vkGetSwapchainGrallocUsageOHOS && "Function <vkGetSwapchainGrallocUsageOHOS> requires <VK_OHOS_native_buffer>" );
31685 # endif
31686
31687 uint64_t grallocUsage;
31688 Result result = static_cast<Result>(
31689 d.vkGetSwapchainGrallocUsageOHOS( m_device, static_cast<VkFormat>( format ), static_cast<VkImageUsageFlags>( imageUsage ), &grallocUsage ) );
31690 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSwapchainGrallocUsageOHOS" );
31691
31692 return detail::createResultValueType( result, std::move( grallocUsage ) );
31693 }
31694 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
31695
31696 # ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
31697 // wrapper function for command vkAcquireImageOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireImageOHOS.html
31698 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
31699 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
31700 Device::acquireImageOHOS( Image image, int32_t nativeFenceFd, Semaphore semaphore, Fence fence, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
31701 {
31702 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
31703 return static_cast<Result>( d.vkAcquireImageOHOS(
31704 static_cast<VkDevice>( m_device ), static_cast<VkImage>( image ), nativeFenceFd, static_cast<VkSemaphore>( semaphore ), static_cast<VkFence>( fence ) ) );
31705 }
31706 # else
31707 // wrapper function for command vkAcquireImageOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireImageOHOS.html
31708 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
31709 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
31710 Device::acquireImageOHOS( Image image, int32_t nativeFenceFd, Semaphore semaphore, Fence fence, Dispatch const & d ) const
31711 {
31712 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
31713 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
31714 VULKAN_HPP_ASSERT( d.vkAcquireImageOHOS && "Function <vkAcquireImageOHOS> requires <VK_OHOS_native_buffer>" );
31715 # endif
31716
31717 Result result = static_cast<Result>(
31718 d.vkAcquireImageOHOS( m_device, static_cast<VkImage>( image ), nativeFenceFd, static_cast<VkSemaphore>( semaphore ), static_cast<VkFence>( fence ) ) );
31719 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::acquireImageOHOS" );
31720
31721 return detail::createResultValueType( result );
31722 }
31723 # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
31724
31725 // wrapper function for command vkQueueSignalReleaseImageOHOS, see
31726 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSignalReleaseImageOHOS.html
31727 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
31728 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Queue::signalReleaseImageOHOS(
31729 uint32_t waitSemaphoreCount, const Semaphore * pWaitSemaphores, Image image, int32_t * pNativeFenceFd, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
31730 {
31731 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
31732 return static_cast<Result>( d.vkQueueSignalReleaseImageOHOS( static_cast<VkQueue>( m_queue ),
31733 waitSemaphoreCount,
31734 reinterpret_cast<const VkSemaphore *>( pWaitSemaphores ),
31735 static_cast<VkImage>( image ),
31736 pNativeFenceFd ) );
31737 }
31738
31739 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
31740 // wrapper function for command vkQueueSignalReleaseImageOHOS, see
31741 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSignalReleaseImageOHOS.html
31742 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
31743 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<int32_t>::type
31744 Queue::signalReleaseImageOHOS( ArrayProxy<const Semaphore> const & waitSemaphores, Image image, Dispatch const & d ) const
31745 {
31746 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
31747 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
31748 VULKAN_HPP_ASSERT( d.vkQueueSignalReleaseImageOHOS && "Function <vkQueueSignalReleaseImageOHOS> requires <VK_OHOS_native_buffer>" );
31749 # endif
31750
31751 int32_t nativeFenceFd;
31752 Result result = static_cast<Result>( d.vkQueueSignalReleaseImageOHOS(
31753 m_queue, waitSemaphores.size(), reinterpret_cast<const VkSemaphore *>( waitSemaphores.data() ), static_cast<VkImage>( image ), &nativeFenceFd ) );
31754 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::signalReleaseImageOHOS" );
31755
31756 return detail::createResultValueType( result, std::move( nativeFenceFd ) );
31757 }
31758 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
31759 #endif /*VK_USE_PLATFORM_OHOS*/
31760
31761 //=== VK_NV_cooperative_matrix2 ===
31762
31763 // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV, see
31764 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV.html
31765 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
31766 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getCooperativeMatrixFlexibleDimensionsPropertiesNV(
31767 uint32_t * pPropertyCount, CooperativeMatrixFlexibleDimensionsPropertiesNV * pProperties, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
31768 {
31769 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
31770 return static_cast<Result>( d.vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV(
31771 static_cast<VkPhysicalDevice>( m_physicalDevice ),
31772 pPropertyCount,
31773 reinterpret_cast<VkCooperativeMatrixFlexibleDimensionsPropertiesNV *>( pProperties ) ) );
31774 }
31775
31776 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
31777 // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV, see
31778 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV.html
31779 template <typename CooperativeMatrixFlexibleDimensionsPropertiesNVAllocator,
31780 typename Dispatch,
31781 typename std::enable_if<std::is_same<typename CooperativeMatrixFlexibleDimensionsPropertiesNVAllocator::value_type,
31782 CooperativeMatrixFlexibleDimensionsPropertiesNV>::value,
31783 int>::type,
31784 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
31785 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
31786 typename ResultValueType<std::vector<CooperativeMatrixFlexibleDimensionsPropertiesNV, CooperativeMatrixFlexibleDimensionsPropertiesNVAllocator>>::type
31787 PhysicalDevice::getCooperativeMatrixFlexibleDimensionsPropertiesNV( Dispatch const & d ) const
31788 {
31789 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
31790 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
31791 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV &&
31792 "Function <vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV> requires <VK_NV_cooperative_matrix2>" );
31793 # endif
31794
31795 std::vector<CooperativeMatrixFlexibleDimensionsPropertiesNV, CooperativeMatrixFlexibleDimensionsPropertiesNVAllocator> properties;
31796 uint32_t propertyCount;
31797 Result result;
31798 do
31799 {
31800 result = static_cast<Result>( d.vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV( m_physicalDevice, &propertyCount, nullptr ) );
31801 if ( ( result == Result::eSuccess ) && propertyCount )
31802 {
31803 properties.resize( propertyCount );
31804 result = static_cast<Result>( d.vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV(
31805 m_physicalDevice, &propertyCount, reinterpret_cast<VkCooperativeMatrixFlexibleDimensionsPropertiesNV *>( properties.data() ) ) );
31806 }
31807 } while ( result == Result::eIncomplete );
31808 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCooperativeMatrixFlexibleDimensionsPropertiesNV" );
31809 VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
31810 if ( propertyCount < properties.size() )
31811 {
31812 properties.resize( propertyCount );
31813 }
31814 return detail::createResultValueType( result, std::move( properties ) );
31815 }
31816
31817 // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV, see
31818 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV.html
31819 template <typename CooperativeMatrixFlexibleDimensionsPropertiesNVAllocator,
31820 typename Dispatch,
31821 typename std::enable_if<std::is_same<typename CooperativeMatrixFlexibleDimensionsPropertiesNVAllocator::value_type,
31822 CooperativeMatrixFlexibleDimensionsPropertiesNV>::value,
31823 int>::type,
31824 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
31825 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
31826 typename ResultValueType<std::vector<CooperativeMatrixFlexibleDimensionsPropertiesNV, CooperativeMatrixFlexibleDimensionsPropertiesNVAllocator>>::type
31827 PhysicalDevice::getCooperativeMatrixFlexibleDimensionsPropertiesNV(
31828 CooperativeMatrixFlexibleDimensionsPropertiesNVAllocator & cooperativeMatrixFlexibleDimensionsPropertiesNVAllocator, Dispatch const & d ) const
31829 {
31830 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
31831 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
31832 VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV &&
31833 "Function <vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV> requires <VK_NV_cooperative_matrix2>" );
31834 # endif
31835
31836 std::vector<CooperativeMatrixFlexibleDimensionsPropertiesNV, CooperativeMatrixFlexibleDimensionsPropertiesNVAllocator> properties(
31837 cooperativeMatrixFlexibleDimensionsPropertiesNVAllocator );
31838 uint32_t propertyCount;
31839 Result result;
31840 do
31841 {
31842 result = static_cast<Result>( d.vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV( m_physicalDevice, &propertyCount, nullptr ) );
31843 if ( ( result == Result::eSuccess ) && propertyCount )
31844 {
31845 properties.resize( propertyCount );
31846 result = static_cast<Result>( d.vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV(
31847 m_physicalDevice, &propertyCount, reinterpret_cast<VkCooperativeMatrixFlexibleDimensionsPropertiesNV *>( properties.data() ) ) );
31848 }
31849 } while ( result == Result::eIncomplete );
31850 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCooperativeMatrixFlexibleDimensionsPropertiesNV" );
31851 VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
31852 if ( propertyCount < properties.size() )
31853 {
31854 properties.resize( propertyCount );
31855 }
31856 return detail::createResultValueType( result, std::move( properties ) );
31857 }
31858 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
31859
31860 #if defined( VK_USE_PLATFORM_METAL_EXT )
31861 //=== VK_EXT_external_memory_metal ===
31862
31863 // wrapper function for command vkGetMemoryMetalHandleEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryMetalHandleEXT.html
31864 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
31865 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getMemoryMetalHandleEXT( const MemoryGetMetalHandleInfoEXT * pGetMetalHandleInfo,
31866 void ** pHandle,
31867 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
31868 {
31869 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
31870 return static_cast<Result>( d.vkGetMemoryMetalHandleEXT(
31871 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkMemoryGetMetalHandleInfoEXT *>( pGetMetalHandleInfo ), pHandle ) );
31872 }
31873
31874 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
31875 // wrapper function for command vkGetMemoryMetalHandleEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryMetalHandleEXT.html
31876 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
31877 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<void *>::type
31878 Device::getMemoryMetalHandleEXT( const MemoryGetMetalHandleInfoEXT & getMetalHandleInfo, Dispatch const & d ) const
31879 {
31880 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
31881 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
31882 VULKAN_HPP_ASSERT( d.vkGetMemoryMetalHandleEXT && "Function <vkGetMemoryMetalHandleEXT> requires <VK_EXT_external_memory_metal>" );
31883 # endif
31884
31885 void * handle;
31886 Result result =
31887 static_cast<Result>( d.vkGetMemoryMetalHandleEXT( m_device, reinterpret_cast<const VkMemoryGetMetalHandleInfoEXT *>( &getMetalHandleInfo ), &handle ) );
31888 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryMetalHandleEXT" );
31889
31890 return detail::createResultValueType( result, std::move( handle ) );
31891 }
31892 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
31893
31894 // wrapper function for command vkGetMemoryMetalHandlePropertiesEXT, see
31895 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryMetalHandlePropertiesEXT.html
31896 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
31897 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getMemoryMetalHandlePropertiesEXT( ExternalMemoryHandleTypeFlagBits handleType,
31898 const void * pHandle,
31899 MemoryMetalHandlePropertiesEXT * pMemoryMetalHandleProperties,
31900 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
31901 {
31902 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
31903 return static_cast<Result>( d.vkGetMemoryMetalHandlePropertiesEXT( static_cast<VkDevice>( m_device ),
31904 static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ),
31905 pHandle,
31906 reinterpret_cast<VkMemoryMetalHandlePropertiesEXT *>( pMemoryMetalHandleProperties ) ) );
31907 }
31908
31909 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
31910 // wrapper function for command vkGetMemoryMetalHandlePropertiesEXT, see
31911 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryMetalHandlePropertiesEXT.html
31912 template <typename HandleType, typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
31913 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<MemoryMetalHandlePropertiesEXT>::type
31914 Device::getMemoryMetalHandlePropertiesEXT( ExternalMemoryHandleTypeFlagBits handleType, HandleType const & handle, Dispatch const & d ) const
31915 {
31916 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
31917 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
31918 VULKAN_HPP_ASSERT( d.vkGetMemoryMetalHandlePropertiesEXT && "Function <vkGetMemoryMetalHandlePropertiesEXT> requires <VK_EXT_external_memory_metal>" );
31919 # endif
31920
31921 MemoryMetalHandlePropertiesEXT memoryMetalHandleProperties;
31922 Result result =
31923 static_cast<Result>( d.vkGetMemoryMetalHandlePropertiesEXT( m_device,
31924 static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ),
31925 reinterpret_cast<const void *>( &handle ),
31926 reinterpret_cast<VkMemoryMetalHandlePropertiesEXT *>( &memoryMetalHandleProperties ) ) );
31927 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryMetalHandlePropertiesEXT" );
31928
31929 return detail::createResultValueType( result, std::move( memoryMetalHandleProperties ) );
31930 }
31931 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
31932 #endif /*VK_USE_PLATFORM_METAL_EXT*/
31933
31934 //=== VK_ARM_performance_counters_by_region ===
31935
31936 // wrapper function for command vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM, see
31937 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM.html
31938 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
31939 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
31940 PhysicalDevice::enumerateQueueFamilyPerformanceCountersByRegionARM( uint32_t queueFamilyIndex,
31941 uint32_t * pCounterCount,
31942 PerformanceCounterARM * pCounters,
31943 PerformanceCounterDescriptionARM * pCounterDescriptions,
31944 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
31945 {
31946 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
31947 return static_cast<Result>(
31948 d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM( static_cast<VkPhysicalDevice>( m_physicalDevice ),
31949 queueFamilyIndex,
31950 pCounterCount,
31951 reinterpret_cast<VkPerformanceCounterARM *>( pCounters ),
31952 reinterpret_cast<VkPerformanceCounterDescriptionARM *>( pCounterDescriptions ) ) );
31953 }
31954
31955 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
31956 // wrapper function for command vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM, see
31957 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM.html
31958 template <typename PerformanceCounterARMAllocator,
31959 typename PerformanceCounterDescriptionARMAllocator,
31960 typename Dispatch,
31961 typename std::enable_if<std::is_same<typename PerformanceCounterARMAllocator::value_type, PerformanceCounterARM>::value &&
31962 std::is_same<typename PerformanceCounterDescriptionARMAllocator::value_type, PerformanceCounterDescriptionARM>::value,
31963 int>::type,
31964 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
31965 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
31966 typename ResultValueType<std::pair<std::vector<PerformanceCounterARM, PerformanceCounterARMAllocator>,
31967 std::vector<PerformanceCounterDescriptionARM, PerformanceCounterDescriptionARMAllocator>>>::type
31968 PhysicalDevice::enumerateQueueFamilyPerformanceCountersByRegionARM( uint32_t queueFamilyIndex, Dispatch const & d ) const
31969 {
31970 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
31971 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
31972 VULKAN_HPP_ASSERT( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM &&
31973 "Function <vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM> requires <VK_ARM_performance_counters_by_region>" );
31974 # endif
31975
31976 std::pair<std::vector<PerformanceCounterARM, PerformanceCounterARMAllocator>,
31977 std::vector<PerformanceCounterDescriptionARM, PerformanceCounterDescriptionARMAllocator>>
31978 data_;
31979 std::vector<PerformanceCounterARM, PerformanceCounterARMAllocator> & counters = data_.first;
31980 std::vector<PerformanceCounterDescriptionARM, PerformanceCounterDescriptionARMAllocator> & counterDescriptions = data_.second;
31981 uint32_t counterCount;
31982 Result result;
31983 do
31984 {
31985 result = static_cast<Result>(
31986 d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM( m_physicalDevice, queueFamilyIndex, &counterCount, nullptr, nullptr ) );
31987 if ( ( result == Result::eSuccess ) && counterCount )
31988 {
31989 counters.resize( counterCount );
31990 counterDescriptions.resize( counterCount );
31991 result = static_cast<Result>( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM(
31992 m_physicalDevice,
31993 queueFamilyIndex,
31994 &counterCount,
31995 reinterpret_cast<VkPerformanceCounterARM *>( counters.data() ),
31996 reinterpret_cast<VkPerformanceCounterDescriptionARM *>( counterDescriptions.data() ) ) );
31997 }
31998 } while ( result == Result::eIncomplete );
31999 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateQueueFamilyPerformanceCountersByRegionARM" );
32000 VULKAN_HPP_ASSERT( counterCount <= counters.size() );
32001 if ( counterCount < counters.size() )
32002 {
32003 counters.resize( counterCount );
32004 counterDescriptions.resize( counterCount );
32005 }
32006 return detail::createResultValueType( result, std::move( data_ ) );
32007 }
32008
32009 // wrapper function for command vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM, see
32010 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM.html
32011 template <typename PerformanceCounterARMAllocator,
32012 typename PerformanceCounterDescriptionARMAllocator,
32013 typename Dispatch,
32014 typename std::enable_if<std::is_same<typename PerformanceCounterARMAllocator::value_type, PerformanceCounterARM>::value &&
32015 std::is_same<typename PerformanceCounterDescriptionARMAllocator::value_type, PerformanceCounterDescriptionARM>::value,
32016 int>::type,
32017 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
32018 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
32019 typename ResultValueType<std::pair<std::vector<PerformanceCounterARM, PerformanceCounterARMAllocator>,
32020 std::vector<PerformanceCounterDescriptionARM, PerformanceCounterDescriptionARMAllocator>>>::type
32021 PhysicalDevice::enumerateQueueFamilyPerformanceCountersByRegionARM( uint32_t queueFamilyIndex,
32022 PerformanceCounterARMAllocator & performanceCounterARMAllocator,
32023 PerformanceCounterDescriptionARMAllocator & performanceCounterDescriptionARMAllocator,
32024 Dispatch const & d ) const
32025 {
32026 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
32027 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
32028 VULKAN_HPP_ASSERT( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM &&
32029 "Function <vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM> requires <VK_ARM_performance_counters_by_region>" );
32030 # endif
32031
32032 std::pair<std::vector<PerformanceCounterARM, PerformanceCounterARMAllocator>,
32033 std::vector<PerformanceCounterDescriptionARM, PerformanceCounterDescriptionARMAllocator>>
32034 data_(
32035 std::piecewise_construct, std::forward_as_tuple( performanceCounterARMAllocator ), std::forward_as_tuple( performanceCounterDescriptionARMAllocator ) );
32036 std::vector<PerformanceCounterARM, PerformanceCounterARMAllocator> & counters = data_.first;
32037 std::vector<PerformanceCounterDescriptionARM, PerformanceCounterDescriptionARMAllocator> & counterDescriptions = data_.second;
32038 uint32_t counterCount;
32039 Result result;
32040 do
32041 {
32042 result = static_cast<Result>(
32043 d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM( m_physicalDevice, queueFamilyIndex, &counterCount, nullptr, nullptr ) );
32044 if ( ( result == Result::eSuccess ) && counterCount )
32045 {
32046 counters.resize( counterCount );
32047 counterDescriptions.resize( counterCount );
32048 result = static_cast<Result>( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM(
32049 m_physicalDevice,
32050 queueFamilyIndex,
32051 &counterCount,
32052 reinterpret_cast<VkPerformanceCounterARM *>( counters.data() ),
32053 reinterpret_cast<VkPerformanceCounterDescriptionARM *>( counterDescriptions.data() ) ) );
32054 }
32055 } while ( result == Result::eIncomplete );
32056 detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateQueueFamilyPerformanceCountersByRegionARM" );
32057 VULKAN_HPP_ASSERT( counterCount <= counters.size() );
32058 if ( counterCount < counters.size() )
32059 {
32060 counters.resize( counterCount );
32061 counterDescriptions.resize( counterCount );
32062 }
32063 return detail::createResultValueType( result, std::move( data_ ) );
32064 }
32065 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
32066
32067 //=== VK_EXT_fragment_density_map_offset ===
32068
32069 // wrapper function for command vkCmdEndRendering2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering2EXT.html
32070 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
32071 VULKAN_HPP_INLINE void CommandBuffer::endRendering2EXT( const RenderingEndInfoKHR * pRenderingEndInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
32072 {
32073 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
32074 d.vkCmdEndRendering2EXT( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkRenderingEndInfoKHR *>( pRenderingEndInfo ) );
32075 }
32076
32077 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
32078 // wrapper function for command vkCmdEndRendering2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering2EXT.html
32079 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
32080 VULKAN_HPP_INLINE void CommandBuffer::endRendering2EXT( Optional<const RenderingEndInfoKHR> renderingEndInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
32081 {
32082 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
32083 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
32084 VULKAN_HPP_ASSERT( d.vkCmdEndRendering2EXT && "Function <vkCmdEndRendering2EXT> requires <VK_EXT_fragment_density_map_offset> or <VK_KHR_maintenance10>" );
32085 # endif
32086
32087 d.vkCmdEndRendering2EXT( m_commandBuffer, reinterpret_cast<const VkRenderingEndInfoKHR *>( renderingEndInfo.get() ) );
32088 }
32089 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
32090
32091 //=== VK_EXT_custom_resolve ===
32092
32093 // wrapper function for command vkCmdBeginCustomResolveEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginCustomResolveEXT.html
32094 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
32095 VULKAN_HPP_INLINE void CommandBuffer::beginCustomResolveEXT( const BeginCustomResolveInfoEXT * pBeginCustomResolveInfo,
32096 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
32097 {
32098 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
32099 d.vkCmdBeginCustomResolveEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
32100 reinterpret_cast<const VkBeginCustomResolveInfoEXT *>( pBeginCustomResolveInfo ) );
32101 }
32102
32103 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
32104 // wrapper function for command vkCmdBeginCustomResolveEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginCustomResolveEXT.html
32105 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
32106 VULKAN_HPP_INLINE void CommandBuffer::beginCustomResolveEXT( Optional<const BeginCustomResolveInfoEXT> beginCustomResolveInfo,
32107 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
32108 {
32109 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
32110 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
32111 VULKAN_HPP_ASSERT( d.vkCmdBeginCustomResolveEXT && "Function <vkCmdBeginCustomResolveEXT> requires <VK_EXT_custom_resolve>" );
32112 # endif
32113
32114 d.vkCmdBeginCustomResolveEXT( m_commandBuffer, reinterpret_cast<const VkBeginCustomResolveInfoEXT *>( beginCustomResolveInfo.get() ) );
32115 }
32116 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
32117
32118 //=== VK_KHR_maintenance10 ===
32119
32120 // wrapper function for command vkCmdEndRendering2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering2KHR.html
32121 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
32122 VULKAN_HPP_INLINE void CommandBuffer::endRendering2KHR( const RenderingEndInfoKHR * pRenderingEndInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
32123 {
32124 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
32125 d.vkCmdEndRendering2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkRenderingEndInfoKHR *>( pRenderingEndInfo ) );
32126 }
32127
32128 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
32129 // wrapper function for command vkCmdEndRendering2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering2KHR.html
32130 template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
32131 VULKAN_HPP_INLINE void CommandBuffer::endRendering2KHR( Optional<const RenderingEndInfoKHR> renderingEndInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
32132 {
32133 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
32134 # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
32135 VULKAN_HPP_ASSERT( d.vkCmdEndRendering2KHR && "Function <vkCmdEndRendering2KHR> requires <VK_EXT_fragment_density_map_offset> or <VK_KHR_maintenance10>" );
32136 # endif
32137
32138 d.vkCmdEndRendering2KHR( m_commandBuffer, reinterpret_cast<const VkRenderingEndInfoKHR *>( renderingEndInfo.get() ) );
32139 }
32140 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
32141
32142 } // namespace VULKAN_HPP_NAMESPACE
32143 #endif