|
1501
|
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 *>( ©BufferInfo ) );
|
|
|
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 *>( ©ImageInfo ) );
|
|
|
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 *>( ©BufferToImageInfo ) );
|
|
|
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 *>( ©ImageToBufferInfo ) );
|
|
|
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 *>( ©MemoryToImageInfo ) ) );
|
|
|
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 *>( ©ImageToMemoryInfo ) ) );
|
|
|
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 *>( ©ImageToImageInfo ) ) );
|
|
|
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 *>( ×tampInfo ), ×tamp, &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 *>( ©MemoryToImageInfo ) ) );
|
|
|
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 *>( ©ImageToMemoryInfo ) ) );
|
|
|
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 *>( ©ImageToImageInfo ) ) );
|
|
|
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 *>( ©BufferInfo ) );
|
|
|
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 *>( ©ImageInfo ) );
|
|
|
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 *>( ©BufferToImageInfo ) );
|
|
|
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 *>( ©ImageToBufferInfo ) );
|
|
|
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 *>( µmap ) ) );
|
|
|
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 *>( µmap ) ) );
|
|
|
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 *>( ©TensorInfo ) );
|
|
|
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 *>( ×tampInfo ), ×tamp, &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 *>( ©MemoryIndirectInfo ) );
|
|
|
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 *>( ©MemoryToImageIndirectInfo ) );
|
|
|
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
|