Mercurial > games > semicongine

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

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
did: correct vulkan-api generator
author sam <sam@basx.dev>
date Wed, 26 Nov 2025 23:34:29 +0700
parents
children
comparison
equal deleted inserted replaced
1500:91c8c3b7cbf0 1501:f40d9d814c08
1 // Copyright 2015-2025 The Khronos Group Inc.
2 //
3 // SPDX-License-Identifier: Apache-2.0 OR MIT
4 //
5
6 // This header is generated from the Khronos Vulkan XML API Registry.
7
8 #ifndef VULKAN_HANDLES_HPP
9 #define VULKAN_HANDLES_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 //=== STRUCT forward declarations ===
19 //===================================
20
21 //=== VK_VERSION_1_0 ===
22 struct Extent2D;
23 struct Extent3D;
24 struct Offset2D;
25 struct Offset3D;
26 struct Rect2D;
27 struct BaseInStructure;
28 struct BaseOutStructure;
29 struct BufferMemoryBarrier;
30 struct ImageMemoryBarrier;
31 struct MemoryBarrier;
32 struct AllocationCallbacks;
33 struct ApplicationInfo;
34 struct FormatProperties;
35 struct ImageFormatProperties;
36 struct InstanceCreateInfo;
37 struct MemoryHeap;
38 struct MemoryType;
39 struct PhysicalDeviceFeatures;
40 struct PhysicalDeviceLimits;
41 struct PhysicalDeviceMemoryProperties;
42 struct PhysicalDeviceProperties;
43 struct PhysicalDeviceSparseProperties;
44 struct QueueFamilyProperties;
45 struct DeviceCreateInfo;
46 struct DeviceQueueCreateInfo;
47 struct ExtensionProperties;
48 struct LayerProperties;
49 struct SubmitInfo;
50 struct MappedMemoryRange;
51 struct MemoryAllocateInfo;
52 struct MemoryRequirements;
53 struct BindSparseInfo;
54 struct ImageSubresource;
55 struct SparseBufferMemoryBindInfo;
56 struct SparseImageFormatProperties;
57 struct SparseImageMemoryBind;
58 struct SparseImageMemoryBindInfo;
59 struct SparseImageMemoryRequirements;
60 struct SparseImageOpaqueMemoryBindInfo;
61 struct SparseMemoryBind;
62 struct FenceCreateInfo;
63 struct SemaphoreCreateInfo;
64 struct QueryPoolCreateInfo;
65 struct BufferCreateInfo;
66 struct ImageCreateInfo;
67 struct SubresourceLayout;
68 struct ComponentMapping;
69 struct ImageSubresourceRange;
70 struct ImageViewCreateInfo;
71 struct CommandPoolCreateInfo;
72 struct CommandBufferAllocateInfo;
73 struct CommandBufferBeginInfo;
74 struct CommandBufferInheritanceInfo;
75 struct BufferCopy;
76 struct BufferImageCopy;
77 struct ImageCopy;
78 struct ImageSubresourceLayers;
79 struct DispatchIndirectCommand;
80 struct PipelineCacheHeaderVersionOne;
81 struct EventCreateInfo;
82 struct BufferViewCreateInfo;
83 struct ShaderModuleCreateInfo;
84 struct PipelineCacheCreateInfo;
85 struct ComputePipelineCreateInfo;
86 struct PipelineShaderStageCreateInfo;
87 struct SpecializationInfo;
88 struct SpecializationMapEntry;
89 struct PipelineLayoutCreateInfo;
90 struct PushConstantRange;
91 struct SamplerCreateInfo;
92 struct CopyDescriptorSet;
93 struct DescriptorBufferInfo;
94 struct DescriptorImageInfo;
95 struct DescriptorPoolCreateInfo;
96 struct DescriptorPoolSize;
97 struct DescriptorSetAllocateInfo;
98 struct DescriptorSetLayoutBinding;
99 struct DescriptorSetLayoutCreateInfo;
100 struct WriteDescriptorSet;
101 union ClearColorValue;
102 struct DrawIndexedIndirectCommand;
103 struct DrawIndirectCommand;
104 struct GraphicsPipelineCreateInfo;
105 struct PipelineColorBlendAttachmentState;
106 struct PipelineColorBlendStateCreateInfo;
107 struct PipelineDepthStencilStateCreateInfo;
108 struct PipelineDynamicStateCreateInfo;
109 struct PipelineInputAssemblyStateCreateInfo;
110 struct PipelineMultisampleStateCreateInfo;
111 struct PipelineRasterizationStateCreateInfo;
112 struct PipelineTessellationStateCreateInfo;
113 struct PipelineVertexInputStateCreateInfo;
114 struct PipelineViewportStateCreateInfo;
115 struct StencilOpState;
116 struct VertexInputAttributeDescription;
117 struct VertexInputBindingDescription;
118 struct Viewport;
119 struct AttachmentDescription;
120 struct AttachmentReference;
121 struct FramebufferCreateInfo;
122 struct RenderPassCreateInfo;
123 struct SubpassDependency;
124 struct SubpassDescription;
125 struct ClearAttachment;
126 struct ClearDepthStencilValue;
127 struct ClearRect;
128 union ClearValue;
129 struct ImageBlit;
130 struct ImageResolve;
131 struct RenderPassBeginInfo;
132
133 //=== VK_VERSION_1_1 ===
134 struct BindBufferMemoryInfo;
135 using BindBufferMemoryInfoKHR = BindBufferMemoryInfo;
136 struct BindImageMemoryInfo;
137 using BindImageMemoryInfoKHR = BindImageMemoryInfo;
138 struct MemoryDedicatedRequirements;
139 using MemoryDedicatedRequirementsKHR = MemoryDedicatedRequirements;
140 struct MemoryDedicatedAllocateInfo;
141 using MemoryDedicatedAllocateInfoKHR = MemoryDedicatedAllocateInfo;
142 struct MemoryAllocateFlagsInfo;
143 using MemoryAllocateFlagsInfoKHR = MemoryAllocateFlagsInfo;
144 struct DeviceGroupCommandBufferBeginInfo;
145 using DeviceGroupCommandBufferBeginInfoKHR = DeviceGroupCommandBufferBeginInfo;
146 struct DeviceGroupSubmitInfo;
147 using DeviceGroupSubmitInfoKHR = DeviceGroupSubmitInfo;
148 struct DeviceGroupBindSparseInfo;
149 using DeviceGroupBindSparseInfoKHR = DeviceGroupBindSparseInfo;
150 struct BindBufferMemoryDeviceGroupInfo;
151 using BindBufferMemoryDeviceGroupInfoKHR = BindBufferMemoryDeviceGroupInfo;
152 struct BindImageMemoryDeviceGroupInfo;
153 using BindImageMemoryDeviceGroupInfoKHR = BindImageMemoryDeviceGroupInfo;
154 struct PhysicalDeviceGroupProperties;
155 using PhysicalDeviceGroupPropertiesKHR = PhysicalDeviceGroupProperties;
156 struct DeviceGroupDeviceCreateInfo;
157 using DeviceGroupDeviceCreateInfoKHR = DeviceGroupDeviceCreateInfo;
158 struct BufferMemoryRequirementsInfo2;
159 using BufferMemoryRequirementsInfo2KHR = BufferMemoryRequirementsInfo2;
160 struct ImageMemoryRequirementsInfo2;
161 using ImageMemoryRequirementsInfo2KHR = ImageMemoryRequirementsInfo2;
162 struct ImageSparseMemoryRequirementsInfo2;
163 using ImageSparseMemoryRequirementsInfo2KHR = ImageSparseMemoryRequirementsInfo2;
164 struct MemoryRequirements2;
165 using MemoryRequirements2KHR = MemoryRequirements2;
166 struct SparseImageMemoryRequirements2;
167 using SparseImageMemoryRequirements2KHR = SparseImageMemoryRequirements2;
168 struct PhysicalDeviceFeatures2;
169 using PhysicalDeviceFeatures2KHR = PhysicalDeviceFeatures2;
170 struct PhysicalDeviceProperties2;
171 using PhysicalDeviceProperties2KHR = PhysicalDeviceProperties2;
172 struct FormatProperties2;
173 using FormatProperties2KHR = FormatProperties2;
174 struct ImageFormatProperties2;
175 using ImageFormatProperties2KHR = ImageFormatProperties2;
176 struct PhysicalDeviceImageFormatInfo2;
177 using PhysicalDeviceImageFormatInfo2KHR = PhysicalDeviceImageFormatInfo2;
178 struct QueueFamilyProperties2;
179 using QueueFamilyProperties2KHR = QueueFamilyProperties2;
180 struct PhysicalDeviceMemoryProperties2;
181 using PhysicalDeviceMemoryProperties2KHR = PhysicalDeviceMemoryProperties2;
182 struct SparseImageFormatProperties2;
183 using SparseImageFormatProperties2KHR = SparseImageFormatProperties2;
184 struct PhysicalDeviceSparseImageFormatInfo2;
185 using PhysicalDeviceSparseImageFormatInfo2KHR = PhysicalDeviceSparseImageFormatInfo2;
186 struct ImageViewUsageCreateInfo;
187 using ImageViewUsageCreateInfoKHR = ImageViewUsageCreateInfo;
188 struct PhysicalDeviceProtectedMemoryFeatures;
189 struct PhysicalDeviceProtectedMemoryProperties;
190 struct DeviceQueueInfo2;
191 struct ProtectedSubmitInfo;
192 struct BindImagePlaneMemoryInfo;
193 using BindImagePlaneMemoryInfoKHR = BindImagePlaneMemoryInfo;
194 struct ImagePlaneMemoryRequirementsInfo;
195 using ImagePlaneMemoryRequirementsInfoKHR = ImagePlaneMemoryRequirementsInfo;
196 struct ExternalMemoryProperties;
197 using ExternalMemoryPropertiesKHR = ExternalMemoryProperties;
198 struct PhysicalDeviceExternalImageFormatInfo;
199 using PhysicalDeviceExternalImageFormatInfoKHR = PhysicalDeviceExternalImageFormatInfo;
200 struct ExternalImageFormatProperties;
201 using ExternalImageFormatPropertiesKHR = ExternalImageFormatProperties;
202 struct PhysicalDeviceExternalBufferInfo;
203 using PhysicalDeviceExternalBufferInfoKHR = PhysicalDeviceExternalBufferInfo;
204 struct ExternalBufferProperties;
205 using ExternalBufferPropertiesKHR = ExternalBufferProperties;
206 struct PhysicalDeviceIDProperties;
207 using PhysicalDeviceIDPropertiesKHR = PhysicalDeviceIDProperties;
208 struct ExternalMemoryImageCreateInfo;
209 using ExternalMemoryImageCreateInfoKHR = ExternalMemoryImageCreateInfo;
210 struct ExternalMemoryBufferCreateInfo;
211 using ExternalMemoryBufferCreateInfoKHR = ExternalMemoryBufferCreateInfo;
212 struct ExportMemoryAllocateInfo;
213 using ExportMemoryAllocateInfoKHR = ExportMemoryAllocateInfo;
214 struct PhysicalDeviceExternalFenceInfo;
215 using PhysicalDeviceExternalFenceInfoKHR = PhysicalDeviceExternalFenceInfo;
216 struct ExternalFenceProperties;
217 using ExternalFencePropertiesKHR = ExternalFenceProperties;
218 struct ExportFenceCreateInfo;
219 using ExportFenceCreateInfoKHR = ExportFenceCreateInfo;
220 struct ExportSemaphoreCreateInfo;
221 using ExportSemaphoreCreateInfoKHR = ExportSemaphoreCreateInfo;
222 struct PhysicalDeviceExternalSemaphoreInfo;
223 using PhysicalDeviceExternalSemaphoreInfoKHR = PhysicalDeviceExternalSemaphoreInfo;
224 struct ExternalSemaphoreProperties;
225 using ExternalSemaphorePropertiesKHR = ExternalSemaphoreProperties;
226 struct PhysicalDeviceSubgroupProperties;
227 struct PhysicalDevice16BitStorageFeatures;
228 using PhysicalDevice16BitStorageFeaturesKHR = PhysicalDevice16BitStorageFeatures;
229 struct PhysicalDeviceVariablePointersFeatures;
230 using PhysicalDeviceVariablePointerFeatures = PhysicalDeviceVariablePointersFeatures;
231 using PhysicalDeviceVariablePointerFeaturesKHR = PhysicalDeviceVariablePointersFeatures;
232 using PhysicalDeviceVariablePointersFeaturesKHR = PhysicalDeviceVariablePointersFeatures;
233 struct DescriptorUpdateTemplateEntry;
234 using DescriptorUpdateTemplateEntryKHR = DescriptorUpdateTemplateEntry;
235 struct DescriptorUpdateTemplateCreateInfo;
236 using DescriptorUpdateTemplateCreateInfoKHR = DescriptorUpdateTemplateCreateInfo;
237 struct PhysicalDeviceMaintenance3Properties;
238 using PhysicalDeviceMaintenance3PropertiesKHR = PhysicalDeviceMaintenance3Properties;
239 struct DescriptorSetLayoutSupport;
240 using DescriptorSetLayoutSupportKHR = DescriptorSetLayoutSupport;
241 struct SamplerYcbcrConversionCreateInfo;
242 using SamplerYcbcrConversionCreateInfoKHR = SamplerYcbcrConversionCreateInfo;
243 struct SamplerYcbcrConversionInfo;
244 using SamplerYcbcrConversionInfoKHR = SamplerYcbcrConversionInfo;
245 struct PhysicalDeviceSamplerYcbcrConversionFeatures;
246 using PhysicalDeviceSamplerYcbcrConversionFeaturesKHR = PhysicalDeviceSamplerYcbcrConversionFeatures;
247 struct SamplerYcbcrConversionImageFormatProperties;
248 using SamplerYcbcrConversionImageFormatPropertiesKHR = SamplerYcbcrConversionImageFormatProperties;
249 struct DeviceGroupRenderPassBeginInfo;
250 using DeviceGroupRenderPassBeginInfoKHR = DeviceGroupRenderPassBeginInfo;
251 struct PhysicalDevicePointClippingProperties;
252 using PhysicalDevicePointClippingPropertiesKHR = PhysicalDevicePointClippingProperties;
253 struct RenderPassInputAttachmentAspectCreateInfo;
254 using RenderPassInputAttachmentAspectCreateInfoKHR = RenderPassInputAttachmentAspectCreateInfo;
255 struct InputAttachmentAspectReference;
256 using InputAttachmentAspectReferenceKHR = InputAttachmentAspectReference;
257 struct PipelineTessellationDomainOriginStateCreateInfo;
258 using PipelineTessellationDomainOriginStateCreateInfoKHR = PipelineTessellationDomainOriginStateCreateInfo;
259 struct RenderPassMultiviewCreateInfo;
260 using RenderPassMultiviewCreateInfoKHR = RenderPassMultiviewCreateInfo;
261 struct PhysicalDeviceMultiviewFeatures;
262 using PhysicalDeviceMultiviewFeaturesKHR = PhysicalDeviceMultiviewFeatures;
263 struct PhysicalDeviceMultiviewProperties;
264 using PhysicalDeviceMultiviewPropertiesKHR = PhysicalDeviceMultiviewProperties;
265 struct PhysicalDeviceShaderDrawParametersFeatures;
266 using PhysicalDeviceShaderDrawParameterFeatures = PhysicalDeviceShaderDrawParametersFeatures;
267
268 //=== VK_VERSION_1_2 ===
269 struct PhysicalDeviceVulkan11Features;
270 struct PhysicalDeviceVulkan11Properties;
271 struct PhysicalDeviceVulkan12Features;
272 struct PhysicalDeviceVulkan12Properties;
273 struct ImageFormatListCreateInfo;
274 using ImageFormatListCreateInfoKHR = ImageFormatListCreateInfo;
275 struct ConformanceVersion;
276 using ConformanceVersionKHR = ConformanceVersion;
277 struct PhysicalDeviceDriverProperties;
278 using PhysicalDeviceDriverPropertiesKHR = PhysicalDeviceDriverProperties;
279 struct PhysicalDeviceVulkanMemoryModelFeatures;
280 using PhysicalDeviceVulkanMemoryModelFeaturesKHR = PhysicalDeviceVulkanMemoryModelFeatures;
281 struct PhysicalDeviceHostQueryResetFeatures;
282 using PhysicalDeviceHostQueryResetFeaturesEXT = PhysicalDeviceHostQueryResetFeatures;
283 struct PhysicalDeviceTimelineSemaphoreFeatures;
284 using PhysicalDeviceTimelineSemaphoreFeaturesKHR = PhysicalDeviceTimelineSemaphoreFeatures;
285 struct PhysicalDeviceTimelineSemaphoreProperties;
286 using PhysicalDeviceTimelineSemaphorePropertiesKHR = PhysicalDeviceTimelineSemaphoreProperties;
287 struct SemaphoreTypeCreateInfo;
288 using SemaphoreTypeCreateInfoKHR = SemaphoreTypeCreateInfo;
289 struct TimelineSemaphoreSubmitInfo;
290 using TimelineSemaphoreSubmitInfoKHR = TimelineSemaphoreSubmitInfo;
291 struct SemaphoreWaitInfo;
292 using SemaphoreWaitInfoKHR = SemaphoreWaitInfo;
293 struct SemaphoreSignalInfo;
294 using SemaphoreSignalInfoKHR = SemaphoreSignalInfo;
295 struct PhysicalDeviceBufferDeviceAddressFeatures;
296 using PhysicalDeviceBufferDeviceAddressFeaturesKHR = PhysicalDeviceBufferDeviceAddressFeatures;
297 struct BufferDeviceAddressInfo;
298 using BufferDeviceAddressInfoEXT = BufferDeviceAddressInfo;
299 using BufferDeviceAddressInfoKHR = BufferDeviceAddressInfo;
300 struct BufferOpaqueCaptureAddressCreateInfo;
301 using BufferOpaqueCaptureAddressCreateInfoKHR = BufferOpaqueCaptureAddressCreateInfo;
302 struct MemoryOpaqueCaptureAddressAllocateInfo;
303 using MemoryOpaqueCaptureAddressAllocateInfoKHR = MemoryOpaqueCaptureAddressAllocateInfo;
304 struct DeviceMemoryOpaqueCaptureAddressInfo;
305 using DeviceMemoryOpaqueCaptureAddressInfoKHR = DeviceMemoryOpaqueCaptureAddressInfo;
306 struct PhysicalDevice8BitStorageFeatures;
307 using PhysicalDevice8BitStorageFeaturesKHR = PhysicalDevice8BitStorageFeatures;
308 struct PhysicalDeviceShaderAtomicInt64Features;
309 using PhysicalDeviceShaderAtomicInt64FeaturesKHR = PhysicalDeviceShaderAtomicInt64Features;
310 struct PhysicalDeviceShaderFloat16Int8Features;
311 using PhysicalDeviceFloat16Int8FeaturesKHR = PhysicalDeviceShaderFloat16Int8Features;
312 using PhysicalDeviceShaderFloat16Int8FeaturesKHR = PhysicalDeviceShaderFloat16Int8Features;
313 struct PhysicalDeviceFloatControlsProperties;
314 using PhysicalDeviceFloatControlsPropertiesKHR = PhysicalDeviceFloatControlsProperties;
315 struct DescriptorSetLayoutBindingFlagsCreateInfo;
316 using DescriptorSetLayoutBindingFlagsCreateInfoEXT = DescriptorSetLayoutBindingFlagsCreateInfo;
317 struct PhysicalDeviceDescriptorIndexingFeatures;
318 using PhysicalDeviceDescriptorIndexingFeaturesEXT = PhysicalDeviceDescriptorIndexingFeatures;
319 struct PhysicalDeviceDescriptorIndexingProperties;
320 using PhysicalDeviceDescriptorIndexingPropertiesEXT = PhysicalDeviceDescriptorIndexingProperties;
321 struct DescriptorSetVariableDescriptorCountAllocateInfo;
322 using DescriptorSetVariableDescriptorCountAllocateInfoEXT = DescriptorSetVariableDescriptorCountAllocateInfo;
323 struct DescriptorSetVariableDescriptorCountLayoutSupport;
324 using DescriptorSetVariableDescriptorCountLayoutSupportEXT = DescriptorSetVariableDescriptorCountLayoutSupport;
325 struct PhysicalDeviceScalarBlockLayoutFeatures;
326 using PhysicalDeviceScalarBlockLayoutFeaturesEXT = PhysicalDeviceScalarBlockLayoutFeatures;
327 struct SamplerReductionModeCreateInfo;
328 using SamplerReductionModeCreateInfoEXT = SamplerReductionModeCreateInfo;
329 struct PhysicalDeviceSamplerFilterMinmaxProperties;
330 using PhysicalDeviceSamplerFilterMinmaxPropertiesEXT = PhysicalDeviceSamplerFilterMinmaxProperties;
331 struct PhysicalDeviceUniformBufferStandardLayoutFeatures;
332 using PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR = PhysicalDeviceUniformBufferStandardLayoutFeatures;
333 struct PhysicalDeviceShaderSubgroupExtendedTypesFeatures;
334 using PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR = PhysicalDeviceShaderSubgroupExtendedTypesFeatures;
335 struct RenderPassCreateInfo2;
336 using RenderPassCreateInfo2KHR = RenderPassCreateInfo2;
337 struct AttachmentDescription2;
338 using AttachmentDescription2KHR = AttachmentDescription2;
339 struct AttachmentReference2;
340 using AttachmentReference2KHR = AttachmentReference2;
341 struct SubpassDescription2;
342 using SubpassDescription2KHR = SubpassDescription2;
343 struct SubpassDependency2;
344 using SubpassDependency2KHR = SubpassDependency2;
345 struct SubpassBeginInfo;
346 using SubpassBeginInfoKHR = SubpassBeginInfo;
347 struct SubpassEndInfo;
348 using SubpassEndInfoKHR = SubpassEndInfo;
349 struct SubpassDescriptionDepthStencilResolve;
350 using SubpassDescriptionDepthStencilResolveKHR = SubpassDescriptionDepthStencilResolve;
351 struct PhysicalDeviceDepthStencilResolveProperties;
352 using PhysicalDeviceDepthStencilResolvePropertiesKHR = PhysicalDeviceDepthStencilResolveProperties;
353 struct ImageStencilUsageCreateInfo;
354 using ImageStencilUsageCreateInfoEXT = ImageStencilUsageCreateInfo;
355 struct PhysicalDeviceImagelessFramebufferFeatures;
356 using PhysicalDeviceImagelessFramebufferFeaturesKHR = PhysicalDeviceImagelessFramebufferFeatures;
357 struct FramebufferAttachmentsCreateInfo;
358 using FramebufferAttachmentsCreateInfoKHR = FramebufferAttachmentsCreateInfo;
359 struct FramebufferAttachmentImageInfo;
360 using FramebufferAttachmentImageInfoKHR = FramebufferAttachmentImageInfo;
361 struct RenderPassAttachmentBeginInfo;
362 using RenderPassAttachmentBeginInfoKHR = RenderPassAttachmentBeginInfo;
363 struct PhysicalDeviceSeparateDepthStencilLayoutsFeatures;
364 using PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR = PhysicalDeviceSeparateDepthStencilLayoutsFeatures;
365 struct AttachmentReferenceStencilLayout;
366 using AttachmentReferenceStencilLayoutKHR = AttachmentReferenceStencilLayout;
367 struct AttachmentDescriptionStencilLayout;
368 using AttachmentDescriptionStencilLayoutKHR = AttachmentDescriptionStencilLayout;
369
370 //=== VK_VERSION_1_3 ===
371 struct PhysicalDeviceVulkan13Features;
372 struct PhysicalDeviceVulkan13Properties;
373 struct PhysicalDeviceToolProperties;
374 using PhysicalDeviceToolPropertiesEXT = PhysicalDeviceToolProperties;
375 struct PhysicalDevicePrivateDataFeatures;
376 using PhysicalDevicePrivateDataFeaturesEXT = PhysicalDevicePrivateDataFeatures;
377 struct DevicePrivateDataCreateInfo;
378 using DevicePrivateDataCreateInfoEXT = DevicePrivateDataCreateInfo;
379 struct PrivateDataSlotCreateInfo;
380 using PrivateDataSlotCreateInfoEXT = PrivateDataSlotCreateInfo;
381 struct MemoryBarrier2;
382 using MemoryBarrier2KHR = MemoryBarrier2;
383 struct BufferMemoryBarrier2;
384 using BufferMemoryBarrier2KHR = BufferMemoryBarrier2;
385 struct ImageMemoryBarrier2;
386 using ImageMemoryBarrier2KHR = ImageMemoryBarrier2;
387 struct DependencyInfo;
388 using DependencyInfoKHR = DependencyInfo;
389 struct SubmitInfo2;
390 using SubmitInfo2KHR = SubmitInfo2;
391 struct SemaphoreSubmitInfo;
392 using SemaphoreSubmitInfoKHR = SemaphoreSubmitInfo;
393 struct CommandBufferSubmitInfo;
394 using CommandBufferSubmitInfoKHR = CommandBufferSubmitInfo;
395 struct PhysicalDeviceSynchronization2Features;
396 using PhysicalDeviceSynchronization2FeaturesKHR = PhysicalDeviceSynchronization2Features;
397 struct CopyBufferInfo2;
398 using CopyBufferInfo2KHR = CopyBufferInfo2;
399 struct CopyImageInfo2;
400 using CopyImageInfo2KHR = CopyImageInfo2;
401 struct CopyBufferToImageInfo2;
402 using CopyBufferToImageInfo2KHR = CopyBufferToImageInfo2;
403 struct CopyImageToBufferInfo2;
404 using CopyImageToBufferInfo2KHR = CopyImageToBufferInfo2;
405 struct BufferCopy2;
406 using BufferCopy2KHR = BufferCopy2;
407 struct ImageCopy2;
408 using ImageCopy2KHR = ImageCopy2;
409 struct BufferImageCopy2;
410 using BufferImageCopy2KHR = BufferImageCopy2;
411 struct PhysicalDeviceTextureCompressionASTCHDRFeatures;
412 using PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT = PhysicalDeviceTextureCompressionASTCHDRFeatures;
413 struct FormatProperties3;
414 using FormatProperties3KHR = FormatProperties3;
415 struct PhysicalDeviceMaintenance4Features;
416 using PhysicalDeviceMaintenance4FeaturesKHR = PhysicalDeviceMaintenance4Features;
417 struct PhysicalDeviceMaintenance4Properties;
418 using PhysicalDeviceMaintenance4PropertiesKHR = PhysicalDeviceMaintenance4Properties;
419 struct DeviceBufferMemoryRequirements;
420 using DeviceBufferMemoryRequirementsKHR = DeviceBufferMemoryRequirements;
421 struct DeviceImageMemoryRequirements;
422 using DeviceImageMemoryRequirementsKHR = DeviceImageMemoryRequirements;
423 struct PipelineCreationFeedbackCreateInfo;
424 using PipelineCreationFeedbackCreateInfoEXT = PipelineCreationFeedbackCreateInfo;
425 struct PipelineCreationFeedback;
426 using PipelineCreationFeedbackEXT = PipelineCreationFeedback;
427 struct PhysicalDeviceShaderTerminateInvocationFeatures;
428 using PhysicalDeviceShaderTerminateInvocationFeaturesKHR = PhysicalDeviceShaderTerminateInvocationFeatures;
429 struct PhysicalDeviceShaderDemoteToHelperInvocationFeatures;
430 using PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT = PhysicalDeviceShaderDemoteToHelperInvocationFeatures;
431 struct PhysicalDevicePipelineCreationCacheControlFeatures;
432 using PhysicalDevicePipelineCreationCacheControlFeaturesEXT = PhysicalDevicePipelineCreationCacheControlFeatures;
433 struct PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures;
434 using PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR = PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures;
435 struct PhysicalDeviceImageRobustnessFeatures;
436 using PhysicalDeviceImageRobustnessFeaturesEXT = PhysicalDeviceImageRobustnessFeatures;
437 struct PhysicalDeviceSubgroupSizeControlFeatures;
438 using PhysicalDeviceSubgroupSizeControlFeaturesEXT = PhysicalDeviceSubgroupSizeControlFeatures;
439 struct PhysicalDeviceSubgroupSizeControlProperties;
440 using PhysicalDeviceSubgroupSizeControlPropertiesEXT = PhysicalDeviceSubgroupSizeControlProperties;
441 struct PipelineShaderStageRequiredSubgroupSizeCreateInfo;
442 using PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT = PipelineShaderStageRequiredSubgroupSizeCreateInfo;
443 using ShaderRequiredSubgroupSizeCreateInfoEXT = PipelineShaderStageRequiredSubgroupSizeCreateInfo;
444 struct PhysicalDeviceInlineUniformBlockFeatures;
445 using PhysicalDeviceInlineUniformBlockFeaturesEXT = PhysicalDeviceInlineUniformBlockFeatures;
446 struct PhysicalDeviceInlineUniformBlockProperties;
447 using PhysicalDeviceInlineUniformBlockPropertiesEXT = PhysicalDeviceInlineUniformBlockProperties;
448 struct WriteDescriptorSetInlineUniformBlock;
449 using WriteDescriptorSetInlineUniformBlockEXT = WriteDescriptorSetInlineUniformBlock;
450 struct DescriptorPoolInlineUniformBlockCreateInfo;
451 using DescriptorPoolInlineUniformBlockCreateInfoEXT = DescriptorPoolInlineUniformBlockCreateInfo;
452 struct PhysicalDeviceShaderIntegerDotProductFeatures;
453 using PhysicalDeviceShaderIntegerDotProductFeaturesKHR = PhysicalDeviceShaderIntegerDotProductFeatures;
454 struct PhysicalDeviceShaderIntegerDotProductProperties;
455 using PhysicalDeviceShaderIntegerDotProductPropertiesKHR = PhysicalDeviceShaderIntegerDotProductProperties;
456 struct PhysicalDeviceTexelBufferAlignmentProperties;
457 using PhysicalDeviceTexelBufferAlignmentPropertiesEXT = PhysicalDeviceTexelBufferAlignmentProperties;
458 struct BlitImageInfo2;
459 using BlitImageInfo2KHR = BlitImageInfo2;
460 struct ImageBlit2;
461 using ImageBlit2KHR = ImageBlit2;
462 struct ResolveImageInfo2;
463 using ResolveImageInfo2KHR = ResolveImageInfo2;
464 struct ImageResolve2;
465 using ImageResolve2KHR = ImageResolve2;
466 struct RenderingInfo;
467 using RenderingInfoKHR = RenderingInfo;
468 struct RenderingAttachmentInfo;
469 using RenderingAttachmentInfoKHR = RenderingAttachmentInfo;
470 struct PipelineRenderingCreateInfo;
471 using PipelineRenderingCreateInfoKHR = PipelineRenderingCreateInfo;
472 struct PhysicalDeviceDynamicRenderingFeatures;
473 using PhysicalDeviceDynamicRenderingFeaturesKHR = PhysicalDeviceDynamicRenderingFeatures;
474 struct CommandBufferInheritanceRenderingInfo;
475 using CommandBufferInheritanceRenderingInfoKHR = CommandBufferInheritanceRenderingInfo;
476
477 //=== VK_VERSION_1_4 ===
478 struct PhysicalDeviceVulkan14Features;
479 struct PhysicalDeviceVulkan14Properties;
480 struct DeviceQueueGlobalPriorityCreateInfo;
481 using DeviceQueueGlobalPriorityCreateInfoEXT = DeviceQueueGlobalPriorityCreateInfo;
482 using DeviceQueueGlobalPriorityCreateInfoKHR = DeviceQueueGlobalPriorityCreateInfo;
483 struct PhysicalDeviceGlobalPriorityQueryFeatures;
484 using PhysicalDeviceGlobalPriorityQueryFeaturesEXT = PhysicalDeviceGlobalPriorityQueryFeatures;
485 using PhysicalDeviceGlobalPriorityQueryFeaturesKHR = PhysicalDeviceGlobalPriorityQueryFeatures;
486 struct QueueFamilyGlobalPriorityProperties;
487 using QueueFamilyGlobalPriorityPropertiesEXT = QueueFamilyGlobalPriorityProperties;
488 using QueueFamilyGlobalPriorityPropertiesKHR = QueueFamilyGlobalPriorityProperties;
489 struct PhysicalDeviceIndexTypeUint8Features;
490 using PhysicalDeviceIndexTypeUint8FeaturesEXT = PhysicalDeviceIndexTypeUint8Features;
491 using PhysicalDeviceIndexTypeUint8FeaturesKHR = PhysicalDeviceIndexTypeUint8Features;
492 struct MemoryMapInfo;
493 using MemoryMapInfoKHR = MemoryMapInfo;
494 struct MemoryUnmapInfo;
495 using MemoryUnmapInfoKHR = MemoryUnmapInfo;
496 struct PhysicalDeviceMaintenance5Features;
497 using PhysicalDeviceMaintenance5FeaturesKHR = PhysicalDeviceMaintenance5Features;
498 struct PhysicalDeviceMaintenance5Properties;
499 using PhysicalDeviceMaintenance5PropertiesKHR = PhysicalDeviceMaintenance5Properties;
500 struct DeviceImageSubresourceInfo;
501 using DeviceImageSubresourceInfoKHR = DeviceImageSubresourceInfo;
502 struct ImageSubresource2;
503 using ImageSubresource2EXT = ImageSubresource2;
504 using ImageSubresource2KHR = ImageSubresource2;
505 struct SubresourceLayout2;
506 using SubresourceLayout2EXT = SubresourceLayout2;
507 using SubresourceLayout2KHR = SubresourceLayout2;
508 struct BufferUsageFlags2CreateInfo;
509 using BufferUsageFlags2CreateInfoKHR = BufferUsageFlags2CreateInfo;
510 struct PhysicalDeviceMaintenance6Features;
511 using PhysicalDeviceMaintenance6FeaturesKHR = PhysicalDeviceMaintenance6Features;
512 struct PhysicalDeviceMaintenance6Properties;
513 using PhysicalDeviceMaintenance6PropertiesKHR = PhysicalDeviceMaintenance6Properties;
514 struct BindMemoryStatus;
515 using BindMemoryStatusKHR = BindMemoryStatus;
516 struct PhysicalDeviceHostImageCopyFeatures;
517 using PhysicalDeviceHostImageCopyFeaturesEXT = PhysicalDeviceHostImageCopyFeatures;
518 struct PhysicalDeviceHostImageCopyProperties;
519 using PhysicalDeviceHostImageCopyPropertiesEXT = PhysicalDeviceHostImageCopyProperties;
520 struct MemoryToImageCopy;
521 using MemoryToImageCopyEXT = MemoryToImageCopy;
522 struct ImageToMemoryCopy;
523 using ImageToMemoryCopyEXT = ImageToMemoryCopy;
524 struct CopyMemoryToImageInfo;
525 using CopyMemoryToImageInfoEXT = CopyMemoryToImageInfo;
526 struct CopyImageToMemoryInfo;
527 using CopyImageToMemoryInfoEXT = CopyImageToMemoryInfo;
528 struct CopyImageToImageInfo;
529 using CopyImageToImageInfoEXT = CopyImageToImageInfo;
530 struct HostImageLayoutTransitionInfo;
531 using HostImageLayoutTransitionInfoEXT = HostImageLayoutTransitionInfo;
532 struct SubresourceHostMemcpySize;
533 using SubresourceHostMemcpySizeEXT = SubresourceHostMemcpySize;
534 struct HostImageCopyDevicePerformanceQuery;
535 using HostImageCopyDevicePerformanceQueryEXT = HostImageCopyDevicePerformanceQuery;
536 struct PhysicalDeviceShaderSubgroupRotateFeatures;
537 using PhysicalDeviceShaderSubgroupRotateFeaturesKHR = PhysicalDeviceShaderSubgroupRotateFeatures;
538 struct PhysicalDeviceShaderFloatControls2Features;
539 using PhysicalDeviceShaderFloatControls2FeaturesKHR = PhysicalDeviceShaderFloatControls2Features;
540 struct PhysicalDeviceShaderExpectAssumeFeatures;
541 using PhysicalDeviceShaderExpectAssumeFeaturesKHR = PhysicalDeviceShaderExpectAssumeFeatures;
542 struct PipelineCreateFlags2CreateInfo;
543 using PipelineCreateFlags2CreateInfoKHR = PipelineCreateFlags2CreateInfo;
544 struct PhysicalDevicePushDescriptorProperties;
545 using PhysicalDevicePushDescriptorPropertiesKHR = PhysicalDevicePushDescriptorProperties;
546 struct BindDescriptorSetsInfo;
547 using BindDescriptorSetsInfoKHR = BindDescriptorSetsInfo;
548 struct PushConstantsInfo;
549 using PushConstantsInfoKHR = PushConstantsInfo;
550 struct PushDescriptorSetInfo;
551 using PushDescriptorSetInfoKHR = PushDescriptorSetInfo;
552 struct PushDescriptorSetWithTemplateInfo;
553 using PushDescriptorSetWithTemplateInfoKHR = PushDescriptorSetWithTemplateInfo;
554 struct PhysicalDevicePipelineProtectedAccessFeatures;
555 using PhysicalDevicePipelineProtectedAccessFeaturesEXT = PhysicalDevicePipelineProtectedAccessFeatures;
556 struct PhysicalDevicePipelineRobustnessFeatures;
557 using PhysicalDevicePipelineRobustnessFeaturesEXT = PhysicalDevicePipelineRobustnessFeatures;
558 struct PhysicalDevicePipelineRobustnessProperties;
559 using PhysicalDevicePipelineRobustnessPropertiesEXT = PhysicalDevicePipelineRobustnessProperties;
560 struct PipelineRobustnessCreateInfo;
561 using PipelineRobustnessCreateInfoEXT = PipelineRobustnessCreateInfo;
562 struct PhysicalDeviceLineRasterizationFeatures;
563 using PhysicalDeviceLineRasterizationFeaturesEXT = PhysicalDeviceLineRasterizationFeatures;
564 using PhysicalDeviceLineRasterizationFeaturesKHR = PhysicalDeviceLineRasterizationFeatures;
565 struct PhysicalDeviceLineRasterizationProperties;
566 using PhysicalDeviceLineRasterizationPropertiesEXT = PhysicalDeviceLineRasterizationProperties;
567 using PhysicalDeviceLineRasterizationPropertiesKHR = PhysicalDeviceLineRasterizationProperties;
568 struct PipelineRasterizationLineStateCreateInfo;
569 using PipelineRasterizationLineStateCreateInfoEXT = PipelineRasterizationLineStateCreateInfo;
570 using PipelineRasterizationLineStateCreateInfoKHR = PipelineRasterizationLineStateCreateInfo;
571 struct PhysicalDeviceVertexAttributeDivisorProperties;
572 using PhysicalDeviceVertexAttributeDivisorPropertiesKHR = PhysicalDeviceVertexAttributeDivisorProperties;
573 struct VertexInputBindingDivisorDescription;
574 using VertexInputBindingDivisorDescriptionEXT = VertexInputBindingDivisorDescription;
575 using VertexInputBindingDivisorDescriptionKHR = VertexInputBindingDivisorDescription;
576 struct PipelineVertexInputDivisorStateCreateInfo;
577 using PipelineVertexInputDivisorStateCreateInfoEXT = PipelineVertexInputDivisorStateCreateInfo;
578 using PipelineVertexInputDivisorStateCreateInfoKHR = PipelineVertexInputDivisorStateCreateInfo;
579 struct PhysicalDeviceVertexAttributeDivisorFeatures;
580 using PhysicalDeviceVertexAttributeDivisorFeaturesEXT = PhysicalDeviceVertexAttributeDivisorFeatures;
581 using PhysicalDeviceVertexAttributeDivisorFeaturesKHR = PhysicalDeviceVertexAttributeDivisorFeatures;
582 struct RenderingAreaInfo;
583 using RenderingAreaInfoKHR = RenderingAreaInfo;
584 struct PhysicalDeviceDynamicRenderingLocalReadFeatures;
585 using PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR = PhysicalDeviceDynamicRenderingLocalReadFeatures;
586 struct RenderingAttachmentLocationInfo;
587 using RenderingAttachmentLocationInfoKHR = RenderingAttachmentLocationInfo;
588 struct RenderingInputAttachmentIndexInfo;
589 using RenderingInputAttachmentIndexInfoKHR = RenderingInputAttachmentIndexInfo;
590
591 //=== VK_KHR_surface ===
592 struct SurfaceCapabilitiesKHR;
593 struct SurfaceFormatKHR;
594
595 //=== VK_KHR_swapchain ===
596 struct SwapchainCreateInfoKHR;
597 struct PresentInfoKHR;
598 struct ImageSwapchainCreateInfoKHR;
599 struct BindImageMemorySwapchainInfoKHR;
600 struct AcquireNextImageInfoKHR;
601 struct DeviceGroupPresentCapabilitiesKHR;
602 struct DeviceGroupPresentInfoKHR;
603 struct DeviceGroupSwapchainCreateInfoKHR;
604
605 //=== VK_KHR_display ===
606 struct DisplayModeCreateInfoKHR;
607 struct DisplayModeParametersKHR;
608 struct DisplayModePropertiesKHR;
609 struct DisplayPlaneCapabilitiesKHR;
610 struct DisplayPlanePropertiesKHR;
611 struct DisplayPropertiesKHR;
612 struct DisplaySurfaceCreateInfoKHR;
613
614 //=== VK_KHR_display_swapchain ===
615 struct DisplayPresentInfoKHR;
616
617 #if defined( VK_USE_PLATFORM_XLIB_KHR )
618 //=== VK_KHR_xlib_surface ===
619 struct XlibSurfaceCreateInfoKHR;
620 #endif /*VK_USE_PLATFORM_XLIB_KHR*/
621
622 #if defined( VK_USE_PLATFORM_XCB_KHR )
623 //=== VK_KHR_xcb_surface ===
624 struct XcbSurfaceCreateInfoKHR;
625 #endif /*VK_USE_PLATFORM_XCB_KHR*/
626
627 #if defined( VK_USE_PLATFORM_WAYLAND_KHR )
628 //=== VK_KHR_wayland_surface ===
629 struct WaylandSurfaceCreateInfoKHR;
630 #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
631
632 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
633 //=== VK_KHR_android_surface ===
634 struct AndroidSurfaceCreateInfoKHR;
635 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
636
637 #if defined( VK_USE_PLATFORM_WIN32_KHR )
638 //=== VK_KHR_win32_surface ===
639 struct Win32SurfaceCreateInfoKHR;
640 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
641
642 //=== VK_EXT_debug_report ===
643 struct DebugReportCallbackCreateInfoEXT;
644
645 //=== VK_AMD_rasterization_order ===
646 struct PipelineRasterizationStateRasterizationOrderAMD;
647
648 //=== VK_EXT_debug_marker ===
649 struct DebugMarkerObjectNameInfoEXT;
650 struct DebugMarkerObjectTagInfoEXT;
651 struct DebugMarkerMarkerInfoEXT;
652
653 //=== VK_KHR_video_queue ===
654 struct QueueFamilyQueryResultStatusPropertiesKHR;
655 struct QueueFamilyVideoPropertiesKHR;
656 struct VideoProfileInfoKHR;
657 struct VideoProfileListInfoKHR;
658 struct VideoCapabilitiesKHR;
659 struct PhysicalDeviceVideoFormatInfoKHR;
660 struct VideoFormatPropertiesKHR;
661 struct VideoPictureResourceInfoKHR;
662 struct VideoReferenceSlotInfoKHR;
663 struct VideoSessionMemoryRequirementsKHR;
664 struct BindVideoSessionMemoryInfoKHR;
665 struct VideoSessionCreateInfoKHR;
666 struct VideoSessionParametersCreateInfoKHR;
667 struct VideoSessionParametersUpdateInfoKHR;
668 struct VideoBeginCodingInfoKHR;
669 struct VideoEndCodingInfoKHR;
670 struct VideoCodingControlInfoKHR;
671
672 //=== VK_KHR_video_decode_queue ===
673 struct VideoDecodeCapabilitiesKHR;
674 struct VideoDecodeUsageInfoKHR;
675 struct VideoDecodeInfoKHR;
676
677 //=== VK_NV_dedicated_allocation ===
678 struct DedicatedAllocationImageCreateInfoNV;
679 struct DedicatedAllocationBufferCreateInfoNV;
680 struct DedicatedAllocationMemoryAllocateInfoNV;
681
682 //=== VK_EXT_transform_feedback ===
683 struct PhysicalDeviceTransformFeedbackFeaturesEXT;
684 struct PhysicalDeviceTransformFeedbackPropertiesEXT;
685 struct PipelineRasterizationStateStreamCreateInfoEXT;
686
687 //=== VK_NVX_binary_import ===
688 struct CuModuleCreateInfoNVX;
689 struct CuModuleTexturingModeCreateInfoNVX;
690 struct CuFunctionCreateInfoNVX;
691 struct CuLaunchInfoNVX;
692
693 //=== VK_NVX_image_view_handle ===
694 struct ImageViewHandleInfoNVX;
695 struct ImageViewAddressPropertiesNVX;
696
697 //=== VK_KHR_video_encode_h264 ===
698 struct VideoEncodeH264CapabilitiesKHR;
699 struct VideoEncodeH264QualityLevelPropertiesKHR;
700 struct VideoEncodeH264SessionCreateInfoKHR;
701 struct VideoEncodeH264SessionParametersCreateInfoKHR;
702 struct VideoEncodeH264SessionParametersAddInfoKHR;
703 struct VideoEncodeH264SessionParametersGetInfoKHR;
704 struct VideoEncodeH264SessionParametersFeedbackInfoKHR;
705 struct VideoEncodeH264PictureInfoKHR;
706 struct VideoEncodeH264DpbSlotInfoKHR;
707 struct VideoEncodeH264NaluSliceInfoKHR;
708 struct VideoEncodeH264ProfileInfoKHR;
709 struct VideoEncodeH264RateControlInfoKHR;
710 struct VideoEncodeH264RateControlLayerInfoKHR;
711 struct VideoEncodeH264QpKHR;
712 struct VideoEncodeH264FrameSizeKHR;
713 struct VideoEncodeH264GopRemainingFrameInfoKHR;
714
715 //=== VK_KHR_video_encode_h265 ===
716 struct VideoEncodeH265CapabilitiesKHR;
717 struct VideoEncodeH265SessionCreateInfoKHR;
718 struct VideoEncodeH265QualityLevelPropertiesKHR;
719 struct VideoEncodeH265SessionParametersCreateInfoKHR;
720 struct VideoEncodeH265SessionParametersAddInfoKHR;
721 struct VideoEncodeH265SessionParametersGetInfoKHR;
722 struct VideoEncodeH265SessionParametersFeedbackInfoKHR;
723 struct VideoEncodeH265PictureInfoKHR;
724 struct VideoEncodeH265DpbSlotInfoKHR;
725 struct VideoEncodeH265NaluSliceSegmentInfoKHR;
726 struct VideoEncodeH265ProfileInfoKHR;
727 struct VideoEncodeH265RateControlInfoKHR;
728 struct VideoEncodeH265RateControlLayerInfoKHR;
729 struct VideoEncodeH265QpKHR;
730 struct VideoEncodeH265FrameSizeKHR;
731 struct VideoEncodeH265GopRemainingFrameInfoKHR;
732
733 //=== VK_KHR_video_decode_h264 ===
734 struct VideoDecodeH264ProfileInfoKHR;
735 struct VideoDecodeH264CapabilitiesKHR;
736 struct VideoDecodeH264SessionParametersCreateInfoKHR;
737 struct VideoDecodeH264SessionParametersAddInfoKHR;
738 struct VideoDecodeH264PictureInfoKHR;
739 struct VideoDecodeH264DpbSlotInfoKHR;
740
741 //=== VK_AMD_texture_gather_bias_lod ===
742 struct TextureLODGatherFormatPropertiesAMD;
743
744 //=== VK_AMD_shader_info ===
745 struct ShaderResourceUsageAMD;
746 struct ShaderStatisticsInfoAMD;
747
748 #if defined( VK_USE_PLATFORM_GGP )
749 //=== VK_GGP_stream_descriptor_surface ===
750 struct StreamDescriptorSurfaceCreateInfoGGP;
751 #endif /*VK_USE_PLATFORM_GGP*/
752
753 //=== VK_NV_corner_sampled_image ===
754 struct PhysicalDeviceCornerSampledImageFeaturesNV;
755
756 //=== VK_NV_external_memory_capabilities ===
757 struct ExternalImageFormatPropertiesNV;
758
759 //=== VK_NV_external_memory ===
760 struct ExternalMemoryImageCreateInfoNV;
761 struct ExportMemoryAllocateInfoNV;
762
763 #if defined( VK_USE_PLATFORM_WIN32_KHR )
764 //=== VK_NV_external_memory_win32 ===
765 struct ImportMemoryWin32HandleInfoNV;
766 struct ExportMemoryWin32HandleInfoNV;
767 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
768
769 #if defined( VK_USE_PLATFORM_WIN32_KHR )
770 //=== VK_NV_win32_keyed_mutex ===
771 struct Win32KeyedMutexAcquireReleaseInfoNV;
772 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
773
774 //=== VK_EXT_validation_flags ===
775 struct ValidationFlagsEXT;
776
777 #if defined( VK_USE_PLATFORM_VI_NN )
778 //=== VK_NN_vi_surface ===
779 struct ViSurfaceCreateInfoNN;
780 #endif /*VK_USE_PLATFORM_VI_NN*/
781
782 //=== VK_EXT_astc_decode_mode ===
783 struct ImageViewASTCDecodeModeEXT;
784 struct PhysicalDeviceASTCDecodeFeaturesEXT;
785
786 #if defined( VK_USE_PLATFORM_WIN32_KHR )
787 //=== VK_KHR_external_memory_win32 ===
788 struct ImportMemoryWin32HandleInfoKHR;
789 struct ExportMemoryWin32HandleInfoKHR;
790 struct MemoryWin32HandlePropertiesKHR;
791 struct MemoryGetWin32HandleInfoKHR;
792 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
793
794 //=== VK_KHR_external_memory_fd ===
795 struct ImportMemoryFdInfoKHR;
796 struct MemoryFdPropertiesKHR;
797 struct MemoryGetFdInfoKHR;
798
799 #if defined( VK_USE_PLATFORM_WIN32_KHR )
800 //=== VK_KHR_win32_keyed_mutex ===
801 struct Win32KeyedMutexAcquireReleaseInfoKHR;
802 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
803
804 #if defined( VK_USE_PLATFORM_WIN32_KHR )
805 //=== VK_KHR_external_semaphore_win32 ===
806 struct ImportSemaphoreWin32HandleInfoKHR;
807 struct ExportSemaphoreWin32HandleInfoKHR;
808 struct D3D12FenceSubmitInfoKHR;
809 struct SemaphoreGetWin32HandleInfoKHR;
810 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
811
812 //=== VK_KHR_external_semaphore_fd ===
813 struct ImportSemaphoreFdInfoKHR;
814 struct SemaphoreGetFdInfoKHR;
815
816 //=== VK_EXT_conditional_rendering ===
817 struct ConditionalRenderingBeginInfoEXT;
818 struct PhysicalDeviceConditionalRenderingFeaturesEXT;
819 struct CommandBufferInheritanceConditionalRenderingInfoEXT;
820
821 //=== VK_KHR_incremental_present ===
822 struct PresentRegionsKHR;
823 struct PresentRegionKHR;
824 struct RectLayerKHR;
825
826 //=== VK_NV_clip_space_w_scaling ===
827 struct ViewportWScalingNV;
828 struct PipelineViewportWScalingStateCreateInfoNV;
829
830 //=== VK_EXT_display_surface_counter ===
831 struct SurfaceCapabilities2EXT;
832
833 //=== VK_EXT_display_control ===
834 struct DisplayPowerInfoEXT;
835 struct DeviceEventInfoEXT;
836 struct DisplayEventInfoEXT;
837 struct SwapchainCounterCreateInfoEXT;
838
839 //=== VK_GOOGLE_display_timing ===
840 struct RefreshCycleDurationGOOGLE;
841 struct PastPresentationTimingGOOGLE;
842 struct PresentTimesInfoGOOGLE;
843 struct PresentTimeGOOGLE;
844
845 //=== VK_NVX_multiview_per_view_attributes ===
846 struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX;
847 struct MultiviewPerViewAttributesInfoNVX;
848
849 //=== VK_NV_viewport_swizzle ===
850 struct ViewportSwizzleNV;
851 struct PipelineViewportSwizzleStateCreateInfoNV;
852
853 //=== VK_EXT_discard_rectangles ===
854 struct PhysicalDeviceDiscardRectanglePropertiesEXT;
855 struct PipelineDiscardRectangleStateCreateInfoEXT;
856
857 //=== VK_EXT_conservative_rasterization ===
858 struct PhysicalDeviceConservativeRasterizationPropertiesEXT;
859 struct PipelineRasterizationConservativeStateCreateInfoEXT;
860
861 //=== VK_EXT_depth_clip_enable ===
862 struct PhysicalDeviceDepthClipEnableFeaturesEXT;
863 struct PipelineRasterizationDepthClipStateCreateInfoEXT;
864
865 //=== VK_EXT_hdr_metadata ===
866 struct HdrMetadataEXT;
867 struct XYColorEXT;
868
869 //=== VK_IMG_relaxed_line_rasterization ===
870 struct PhysicalDeviceRelaxedLineRasterizationFeaturesIMG;
871
872 //=== VK_KHR_shared_presentable_image ===
873 struct SharedPresentSurfaceCapabilitiesKHR;
874
875 #if defined( VK_USE_PLATFORM_WIN32_KHR )
876 //=== VK_KHR_external_fence_win32 ===
877 struct ImportFenceWin32HandleInfoKHR;
878 struct ExportFenceWin32HandleInfoKHR;
879 struct FenceGetWin32HandleInfoKHR;
880 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
881
882 //=== VK_KHR_external_fence_fd ===
883 struct ImportFenceFdInfoKHR;
884 struct FenceGetFdInfoKHR;
885
886 //=== VK_KHR_performance_query ===
887 struct PhysicalDevicePerformanceQueryFeaturesKHR;
888 struct PhysicalDevicePerformanceQueryPropertiesKHR;
889 struct PerformanceCounterKHR;
890 struct PerformanceCounterDescriptionKHR;
891 struct QueryPoolPerformanceCreateInfoKHR;
892 union PerformanceCounterResultKHR;
893 struct AcquireProfilingLockInfoKHR;
894 struct PerformanceQuerySubmitInfoKHR;
895
896 //=== VK_KHR_get_surface_capabilities2 ===
897 struct PhysicalDeviceSurfaceInfo2KHR;
898 struct SurfaceCapabilities2KHR;
899 struct SurfaceFormat2KHR;
900
901 //=== VK_KHR_get_display_properties2 ===
902 struct DisplayProperties2KHR;
903 struct DisplayPlaneProperties2KHR;
904 struct DisplayModeProperties2KHR;
905 struct DisplayPlaneInfo2KHR;
906 struct DisplayPlaneCapabilities2KHR;
907
908 #if defined( VK_USE_PLATFORM_IOS_MVK )
909 //=== VK_MVK_ios_surface ===
910 struct IOSSurfaceCreateInfoMVK;
911 #endif /*VK_USE_PLATFORM_IOS_MVK*/
912
913 #if defined( VK_USE_PLATFORM_MACOS_MVK )
914 //=== VK_MVK_macos_surface ===
915 struct MacOSSurfaceCreateInfoMVK;
916 #endif /*VK_USE_PLATFORM_MACOS_MVK*/
917
918 //=== VK_EXT_debug_utils ===
919 struct DebugUtilsLabelEXT;
920 struct DebugUtilsMessengerCallbackDataEXT;
921 struct DebugUtilsMessengerCreateInfoEXT;
922 struct DebugUtilsObjectNameInfoEXT;
923 struct DebugUtilsObjectTagInfoEXT;
924
925 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
926 //=== VK_ANDROID_external_memory_android_hardware_buffer ===
927 struct AndroidHardwareBufferUsageANDROID;
928 struct AndroidHardwareBufferPropertiesANDROID;
929 struct AndroidHardwareBufferFormatPropertiesANDROID;
930 struct ImportAndroidHardwareBufferInfoANDROID;
931 struct MemoryGetAndroidHardwareBufferInfoANDROID;
932 struct ExternalFormatANDROID;
933 struct AndroidHardwareBufferFormatProperties2ANDROID;
934 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
935
936 #if defined( VK_ENABLE_BETA_EXTENSIONS )
937 //=== VK_AMDX_shader_enqueue ===
938 struct PhysicalDeviceShaderEnqueueFeaturesAMDX;
939 struct PhysicalDeviceShaderEnqueuePropertiesAMDX;
940 struct ExecutionGraphPipelineScratchSizeAMDX;
941 struct ExecutionGraphPipelineCreateInfoAMDX;
942 struct DispatchGraphInfoAMDX;
943 struct DispatchGraphCountInfoAMDX;
944 struct PipelineShaderStageNodeCreateInfoAMDX;
945 union DeviceOrHostAddressConstAMDX;
946 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
947
948 //=== VK_AMD_mixed_attachment_samples ===
949 struct AttachmentSampleCountInfoAMD;
950 using AttachmentSampleCountInfoNV = AttachmentSampleCountInfoAMD;
951
952 //=== VK_KHR_shader_bfloat16 ===
953 struct PhysicalDeviceShaderBfloat16FeaturesKHR;
954
955 //=== VK_EXT_sample_locations ===
956 struct SampleLocationEXT;
957 struct SampleLocationsInfoEXT;
958 struct AttachmentSampleLocationsEXT;
959 struct SubpassSampleLocationsEXT;
960 struct RenderPassSampleLocationsBeginInfoEXT;
961 struct PipelineSampleLocationsStateCreateInfoEXT;
962 struct PhysicalDeviceSampleLocationsPropertiesEXT;
963 struct MultisamplePropertiesEXT;
964
965 //=== VK_EXT_blend_operation_advanced ===
966 struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT;
967 struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT;
968 struct PipelineColorBlendAdvancedStateCreateInfoEXT;
969
970 //=== VK_NV_fragment_coverage_to_color ===
971 struct PipelineCoverageToColorStateCreateInfoNV;
972
973 //=== VK_KHR_acceleration_structure ===
974 union DeviceOrHostAddressKHR;
975 union DeviceOrHostAddressConstKHR;
976 struct AccelerationStructureBuildRangeInfoKHR;
977 struct AabbPositionsKHR;
978 using AabbPositionsNV = AabbPositionsKHR;
979 struct AccelerationStructureGeometryTrianglesDataKHR;
980 struct TransformMatrixKHR;
981 using TransformMatrixNV = TransformMatrixKHR;
982 struct AccelerationStructureBuildGeometryInfoKHR;
983 struct AccelerationStructureGeometryAabbsDataKHR;
984 struct AccelerationStructureInstanceKHR;
985 using AccelerationStructureInstanceNV = AccelerationStructureInstanceKHR;
986 struct AccelerationStructureGeometryInstancesDataKHR;
987 union AccelerationStructureGeometryDataKHR;
988 struct AccelerationStructureGeometryKHR;
989 struct AccelerationStructureCreateInfoKHR;
990 struct WriteDescriptorSetAccelerationStructureKHR;
991 struct PhysicalDeviceAccelerationStructureFeaturesKHR;
992 struct PhysicalDeviceAccelerationStructurePropertiesKHR;
993 struct AccelerationStructureDeviceAddressInfoKHR;
994 struct AccelerationStructureVersionInfoKHR;
995 struct CopyAccelerationStructureToMemoryInfoKHR;
996 struct CopyMemoryToAccelerationStructureInfoKHR;
997 struct CopyAccelerationStructureInfoKHR;
998 struct AccelerationStructureBuildSizesInfoKHR;
999
1000 //=== VK_KHR_ray_tracing_pipeline ===
1001 struct RayTracingShaderGroupCreateInfoKHR;
1002 struct RayTracingPipelineCreateInfoKHR;
1003 struct PhysicalDeviceRayTracingPipelineFeaturesKHR;
1004 struct PhysicalDeviceRayTracingPipelinePropertiesKHR;
1005 struct StridedDeviceAddressRegionKHR;
1006 struct TraceRaysIndirectCommandKHR;
1007 struct RayTracingPipelineInterfaceCreateInfoKHR;
1008
1009 //=== VK_KHR_ray_query ===
1010 struct PhysicalDeviceRayQueryFeaturesKHR;
1011
1012 //=== VK_NV_framebuffer_mixed_samples ===
1013 struct PipelineCoverageModulationStateCreateInfoNV;
1014
1015 //=== VK_NV_shader_sm_builtins ===
1016 struct PhysicalDeviceShaderSMBuiltinsPropertiesNV;
1017 struct PhysicalDeviceShaderSMBuiltinsFeaturesNV;
1018
1019 //=== VK_EXT_image_drm_format_modifier ===
1020 struct DrmFormatModifierPropertiesListEXT;
1021 struct DrmFormatModifierPropertiesEXT;
1022 struct PhysicalDeviceImageDrmFormatModifierInfoEXT;
1023 struct ImageDrmFormatModifierListCreateInfoEXT;
1024 struct ImageDrmFormatModifierExplicitCreateInfoEXT;
1025 struct ImageDrmFormatModifierPropertiesEXT;
1026 struct DrmFormatModifierPropertiesList2EXT;
1027 struct DrmFormatModifierProperties2EXT;
1028
1029 //=== VK_EXT_validation_cache ===
1030 struct ValidationCacheCreateInfoEXT;
1031 struct ShaderModuleValidationCacheCreateInfoEXT;
1032
1033 #if defined( VK_ENABLE_BETA_EXTENSIONS )
1034 //=== VK_KHR_portability_subset ===
1035 struct PhysicalDevicePortabilitySubsetFeaturesKHR;
1036 struct PhysicalDevicePortabilitySubsetPropertiesKHR;
1037 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
1038
1039 //=== VK_NV_shading_rate_image ===
1040 struct ShadingRatePaletteNV;
1041 struct PipelineViewportShadingRateImageStateCreateInfoNV;
1042 struct PhysicalDeviceShadingRateImageFeaturesNV;
1043 struct PhysicalDeviceShadingRateImagePropertiesNV;
1044 struct CoarseSampleLocationNV;
1045 struct CoarseSampleOrderCustomNV;
1046 struct PipelineViewportCoarseSampleOrderStateCreateInfoNV;
1047
1048 //=== VK_NV_ray_tracing ===
1049 struct RayTracingShaderGroupCreateInfoNV;
1050 struct RayTracingPipelineCreateInfoNV;
1051 struct GeometryTrianglesNV;
1052 struct GeometryAABBNV;
1053 struct GeometryDataNV;
1054 struct GeometryNV;
1055 struct AccelerationStructureInfoNV;
1056 struct AccelerationStructureCreateInfoNV;
1057 struct BindAccelerationStructureMemoryInfoNV;
1058 struct WriteDescriptorSetAccelerationStructureNV;
1059 struct AccelerationStructureMemoryRequirementsInfoNV;
1060 struct PhysicalDeviceRayTracingPropertiesNV;
1061
1062 //=== VK_NV_representative_fragment_test ===
1063 struct PhysicalDeviceRepresentativeFragmentTestFeaturesNV;
1064 struct PipelineRepresentativeFragmentTestStateCreateInfoNV;
1065
1066 //=== VK_EXT_filter_cubic ===
1067 struct PhysicalDeviceImageViewImageFormatInfoEXT;
1068 struct FilterCubicImageViewImageFormatPropertiesEXT;
1069
1070 //=== VK_EXT_external_memory_host ===
1071 struct ImportMemoryHostPointerInfoEXT;
1072 struct MemoryHostPointerPropertiesEXT;
1073 struct PhysicalDeviceExternalMemoryHostPropertiesEXT;
1074
1075 //=== VK_KHR_shader_clock ===
1076 struct PhysicalDeviceShaderClockFeaturesKHR;
1077
1078 //=== VK_AMD_pipeline_compiler_control ===
1079 struct PipelineCompilerControlCreateInfoAMD;
1080
1081 //=== VK_AMD_shader_core_properties ===
1082 struct PhysicalDeviceShaderCorePropertiesAMD;
1083
1084 //=== VK_KHR_video_decode_h265 ===
1085 struct VideoDecodeH265ProfileInfoKHR;
1086 struct VideoDecodeH265CapabilitiesKHR;
1087 struct VideoDecodeH265SessionParametersCreateInfoKHR;
1088 struct VideoDecodeH265SessionParametersAddInfoKHR;
1089 struct VideoDecodeH265PictureInfoKHR;
1090 struct VideoDecodeH265DpbSlotInfoKHR;
1091
1092 //=== VK_AMD_memory_overallocation_behavior ===
1093 struct DeviceMemoryOverallocationCreateInfoAMD;
1094
1095 //=== VK_EXT_vertex_attribute_divisor ===
1096 struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT;
1097
1098 #if defined( VK_USE_PLATFORM_GGP )
1099 //=== VK_GGP_frame_token ===
1100 struct PresentFrameTokenGGP;
1101 #endif /*VK_USE_PLATFORM_GGP*/
1102
1103 //=== VK_NV_mesh_shader ===
1104 struct PhysicalDeviceMeshShaderFeaturesNV;
1105 struct PhysicalDeviceMeshShaderPropertiesNV;
1106 struct DrawMeshTasksIndirectCommandNV;
1107
1108 //=== VK_NV_shader_image_footprint ===
1109 struct PhysicalDeviceShaderImageFootprintFeaturesNV;
1110
1111 //=== VK_NV_scissor_exclusive ===
1112 struct PipelineViewportExclusiveScissorStateCreateInfoNV;
1113 struct PhysicalDeviceExclusiveScissorFeaturesNV;
1114
1115 //=== VK_NV_device_diagnostic_checkpoints ===
1116 struct QueueFamilyCheckpointPropertiesNV;
1117 struct CheckpointDataNV;
1118 struct QueueFamilyCheckpointProperties2NV;
1119 struct CheckpointData2NV;
1120
1121 //=== VK_INTEL_shader_integer_functions2 ===
1122 struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL;
1123
1124 //=== VK_INTEL_performance_query ===
1125 union PerformanceValueDataINTEL;
1126 struct PerformanceValueINTEL;
1127 struct InitializePerformanceApiInfoINTEL;
1128 struct QueryPoolPerformanceQueryCreateInfoINTEL;
1129 using QueryPoolCreateInfoINTEL = QueryPoolPerformanceQueryCreateInfoINTEL;
1130 struct PerformanceMarkerInfoINTEL;
1131 struct PerformanceStreamMarkerInfoINTEL;
1132 struct PerformanceOverrideInfoINTEL;
1133 struct PerformanceConfigurationAcquireInfoINTEL;
1134
1135 //=== VK_EXT_pci_bus_info ===
1136 struct PhysicalDevicePCIBusInfoPropertiesEXT;
1137
1138 //=== VK_AMD_display_native_hdr ===
1139 struct DisplayNativeHdrSurfaceCapabilitiesAMD;
1140 struct SwapchainDisplayNativeHdrCreateInfoAMD;
1141
1142 #if defined( VK_USE_PLATFORM_FUCHSIA )
1143 //=== VK_FUCHSIA_imagepipe_surface ===
1144 struct ImagePipeSurfaceCreateInfoFUCHSIA;
1145 #endif /*VK_USE_PLATFORM_FUCHSIA*/
1146
1147 #if defined( VK_USE_PLATFORM_METAL_EXT )
1148 //=== VK_EXT_metal_surface ===
1149 struct MetalSurfaceCreateInfoEXT;
1150 #endif /*VK_USE_PLATFORM_METAL_EXT*/
1151
1152 //=== VK_EXT_fragment_density_map ===
1153 struct PhysicalDeviceFragmentDensityMapFeaturesEXT;
1154 struct PhysicalDeviceFragmentDensityMapPropertiesEXT;
1155 struct RenderPassFragmentDensityMapCreateInfoEXT;
1156 struct RenderingFragmentDensityMapAttachmentInfoEXT;
1157
1158 //=== VK_KHR_fragment_shading_rate ===
1159 struct FragmentShadingRateAttachmentInfoKHR;
1160 struct PipelineFragmentShadingRateStateCreateInfoKHR;
1161 struct PhysicalDeviceFragmentShadingRateFeaturesKHR;
1162 struct PhysicalDeviceFragmentShadingRatePropertiesKHR;
1163 struct PhysicalDeviceFragmentShadingRateKHR;
1164 struct RenderingFragmentShadingRateAttachmentInfoKHR;
1165
1166 //=== VK_AMD_shader_core_properties2 ===
1167 struct PhysicalDeviceShaderCoreProperties2AMD;
1168
1169 //=== VK_AMD_device_coherent_memory ===
1170 struct PhysicalDeviceCoherentMemoryFeaturesAMD;
1171
1172 //=== VK_EXT_shader_image_atomic_int64 ===
1173 struct PhysicalDeviceShaderImageAtomicInt64FeaturesEXT;
1174
1175 //=== VK_KHR_shader_quad_control ===
1176 struct PhysicalDeviceShaderQuadControlFeaturesKHR;
1177
1178 //=== VK_EXT_memory_budget ===
1179 struct PhysicalDeviceMemoryBudgetPropertiesEXT;
1180
1181 //=== VK_EXT_memory_priority ===
1182 struct PhysicalDeviceMemoryPriorityFeaturesEXT;
1183 struct MemoryPriorityAllocateInfoEXT;
1184
1185 //=== VK_KHR_surface_protected_capabilities ===
1186 struct SurfaceProtectedCapabilitiesKHR;
1187
1188 //=== VK_NV_dedicated_allocation_image_aliasing ===
1189 struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV;
1190
1191 //=== VK_EXT_buffer_device_address ===
1192 struct PhysicalDeviceBufferDeviceAddressFeaturesEXT;
1193 using PhysicalDeviceBufferAddressFeaturesEXT = PhysicalDeviceBufferDeviceAddressFeaturesEXT;
1194 struct BufferDeviceAddressCreateInfoEXT;
1195
1196 //=== VK_EXT_validation_features ===
1197 struct ValidationFeaturesEXT;
1198
1199 //=== VK_KHR_present_wait ===
1200 struct PhysicalDevicePresentWaitFeaturesKHR;
1201
1202 //=== VK_NV_cooperative_matrix ===
1203 struct CooperativeMatrixPropertiesNV;
1204 struct PhysicalDeviceCooperativeMatrixFeaturesNV;
1205 struct PhysicalDeviceCooperativeMatrixPropertiesNV;
1206
1207 //=== VK_NV_coverage_reduction_mode ===
1208 struct PhysicalDeviceCoverageReductionModeFeaturesNV;
1209 struct PipelineCoverageReductionStateCreateInfoNV;
1210 struct FramebufferMixedSamplesCombinationNV;
1211
1212 //=== VK_EXT_fragment_shader_interlock ===
1213 struct PhysicalDeviceFragmentShaderInterlockFeaturesEXT;
1214
1215 //=== VK_EXT_ycbcr_image_arrays ===
1216 struct PhysicalDeviceYcbcrImageArraysFeaturesEXT;
1217
1218 //=== VK_EXT_provoking_vertex ===
1219 struct PhysicalDeviceProvokingVertexFeaturesEXT;
1220 struct PhysicalDeviceProvokingVertexPropertiesEXT;
1221 struct PipelineRasterizationProvokingVertexStateCreateInfoEXT;
1222
1223 #if defined( VK_USE_PLATFORM_WIN32_KHR )
1224 //=== VK_EXT_full_screen_exclusive ===
1225 struct SurfaceFullScreenExclusiveInfoEXT;
1226 struct SurfaceCapabilitiesFullScreenExclusiveEXT;
1227 struct SurfaceFullScreenExclusiveWin32InfoEXT;
1228 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
1229
1230 //=== VK_EXT_headless_surface ===
1231 struct HeadlessSurfaceCreateInfoEXT;
1232
1233 //=== VK_EXT_shader_atomic_float ===
1234 struct PhysicalDeviceShaderAtomicFloatFeaturesEXT;
1235
1236 //=== VK_EXT_extended_dynamic_state ===
1237 struct PhysicalDeviceExtendedDynamicStateFeaturesEXT;
1238
1239 //=== VK_KHR_pipeline_executable_properties ===
1240 struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHR;
1241 struct PipelineInfoKHR;
1242 using PipelineInfoEXT = PipelineInfoKHR;
1243 struct PipelineExecutablePropertiesKHR;
1244 struct PipelineExecutableInfoKHR;
1245 union PipelineExecutableStatisticValueKHR;
1246 struct PipelineExecutableStatisticKHR;
1247 struct PipelineExecutableInternalRepresentationKHR;
1248
1249 //=== VK_EXT_map_memory_placed ===
1250 struct PhysicalDeviceMapMemoryPlacedFeaturesEXT;
1251 struct PhysicalDeviceMapMemoryPlacedPropertiesEXT;
1252 struct MemoryMapPlacedInfoEXT;
1253
1254 //=== VK_EXT_shader_atomic_float2 ===
1255 struct PhysicalDeviceShaderAtomicFloat2FeaturesEXT;
1256
1257 //=== VK_NV_device_generated_commands ===
1258 struct PhysicalDeviceDeviceGeneratedCommandsPropertiesNV;
1259 struct PhysicalDeviceDeviceGeneratedCommandsFeaturesNV;
1260 struct GraphicsShaderGroupCreateInfoNV;
1261 struct GraphicsPipelineShaderGroupsCreateInfoNV;
1262 struct BindShaderGroupIndirectCommandNV;
1263 struct BindIndexBufferIndirectCommandNV;
1264 struct BindVertexBufferIndirectCommandNV;
1265 struct SetStateFlagsIndirectCommandNV;
1266 struct IndirectCommandsStreamNV;
1267 struct IndirectCommandsLayoutTokenNV;
1268 struct IndirectCommandsLayoutCreateInfoNV;
1269 struct GeneratedCommandsInfoNV;
1270 struct GeneratedCommandsMemoryRequirementsInfoNV;
1271
1272 //=== VK_NV_inherited_viewport_scissor ===
1273 struct PhysicalDeviceInheritedViewportScissorFeaturesNV;
1274 struct CommandBufferInheritanceViewportScissorInfoNV;
1275
1276 //=== VK_EXT_texel_buffer_alignment ===
1277 struct PhysicalDeviceTexelBufferAlignmentFeaturesEXT;
1278
1279 //=== VK_QCOM_render_pass_transform ===
1280 struct RenderPassTransformBeginInfoQCOM;
1281 struct CommandBufferInheritanceRenderPassTransformInfoQCOM;
1282
1283 //=== VK_EXT_depth_bias_control ===
1284 struct PhysicalDeviceDepthBiasControlFeaturesEXT;
1285 struct DepthBiasInfoEXT;
1286 struct DepthBiasRepresentationInfoEXT;
1287
1288 //=== VK_EXT_device_memory_report ===
1289 struct PhysicalDeviceDeviceMemoryReportFeaturesEXT;
1290 struct DeviceDeviceMemoryReportCreateInfoEXT;
1291 struct DeviceMemoryReportCallbackDataEXT;
1292
1293 //=== VK_EXT_custom_border_color ===
1294 struct SamplerCustomBorderColorCreateInfoEXT;
1295 struct PhysicalDeviceCustomBorderColorPropertiesEXT;
1296 struct PhysicalDeviceCustomBorderColorFeaturesEXT;
1297
1298 //=== VK_KHR_pipeline_library ===
1299 struct PipelineLibraryCreateInfoKHR;
1300
1301 //=== VK_NV_present_barrier ===
1302 struct PhysicalDevicePresentBarrierFeaturesNV;
1303 struct SurfaceCapabilitiesPresentBarrierNV;
1304 struct SwapchainPresentBarrierCreateInfoNV;
1305
1306 //=== VK_KHR_present_id ===
1307 struct PresentIdKHR;
1308 struct PhysicalDevicePresentIdFeaturesKHR;
1309
1310 //=== VK_KHR_video_encode_queue ===
1311 struct VideoEncodeInfoKHR;
1312 struct VideoEncodeCapabilitiesKHR;
1313 struct QueryPoolVideoEncodeFeedbackCreateInfoKHR;
1314 struct VideoEncodeUsageInfoKHR;
1315 struct VideoEncodeRateControlInfoKHR;
1316 struct VideoEncodeRateControlLayerInfoKHR;
1317 struct PhysicalDeviceVideoEncodeQualityLevelInfoKHR;
1318 struct VideoEncodeQualityLevelPropertiesKHR;
1319 struct VideoEncodeQualityLevelInfoKHR;
1320 struct VideoEncodeSessionParametersGetInfoKHR;
1321 struct VideoEncodeSessionParametersFeedbackInfoKHR;
1322
1323 //=== VK_NV_device_diagnostics_config ===
1324 struct PhysicalDeviceDiagnosticsConfigFeaturesNV;
1325 struct DeviceDiagnosticsConfigCreateInfoNV;
1326
1327 #if defined( VK_ENABLE_BETA_EXTENSIONS )
1328 //=== VK_NV_cuda_kernel_launch ===
1329 struct CudaModuleCreateInfoNV;
1330 struct CudaFunctionCreateInfoNV;
1331 struct CudaLaunchInfoNV;
1332 struct PhysicalDeviceCudaKernelLaunchFeaturesNV;
1333 struct PhysicalDeviceCudaKernelLaunchPropertiesNV;
1334 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
1335
1336 //=== VK_QCOM_tile_shading ===
1337 struct PhysicalDeviceTileShadingFeaturesQCOM;
1338 struct PhysicalDeviceTileShadingPropertiesQCOM;
1339 struct RenderPassTileShadingCreateInfoQCOM;
1340 struct PerTileBeginInfoQCOM;
1341 struct PerTileEndInfoQCOM;
1342 struct DispatchTileInfoQCOM;
1343
1344 //=== VK_NV_low_latency ===
1345 struct QueryLowLatencySupportNV;
1346
1347 #if defined( VK_USE_PLATFORM_METAL_EXT )
1348 //=== VK_EXT_metal_objects ===
1349 struct ExportMetalObjectCreateInfoEXT;
1350 struct ExportMetalObjectsInfoEXT;
1351 struct ExportMetalDeviceInfoEXT;
1352 struct ExportMetalCommandQueueInfoEXT;
1353 struct ExportMetalBufferInfoEXT;
1354 struct ImportMetalBufferInfoEXT;
1355 struct ExportMetalTextureInfoEXT;
1356 struct ImportMetalTextureInfoEXT;
1357 struct ExportMetalIOSurfaceInfoEXT;
1358 struct ImportMetalIOSurfaceInfoEXT;
1359 struct ExportMetalSharedEventInfoEXT;
1360 struct ImportMetalSharedEventInfoEXT;
1361 #endif /*VK_USE_PLATFORM_METAL_EXT*/
1362
1363 //=== VK_EXT_descriptor_buffer ===
1364 struct PhysicalDeviceDescriptorBufferPropertiesEXT;
1365 struct PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT;
1366 struct PhysicalDeviceDescriptorBufferFeaturesEXT;
1367 struct DescriptorAddressInfoEXT;
1368 struct DescriptorBufferBindingInfoEXT;
1369 struct DescriptorBufferBindingPushDescriptorBufferHandleEXT;
1370 union DescriptorDataEXT;
1371 struct DescriptorGetInfoEXT;
1372 struct BufferCaptureDescriptorDataInfoEXT;
1373 struct ImageCaptureDescriptorDataInfoEXT;
1374 struct ImageViewCaptureDescriptorDataInfoEXT;
1375 struct SamplerCaptureDescriptorDataInfoEXT;
1376 struct OpaqueCaptureDescriptorDataCreateInfoEXT;
1377 struct AccelerationStructureCaptureDescriptorDataInfoEXT;
1378
1379 //=== VK_EXT_graphics_pipeline_library ===
1380 struct PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT;
1381 struct PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT;
1382 struct GraphicsPipelineLibraryCreateInfoEXT;
1383
1384 //=== VK_AMD_shader_early_and_late_fragment_tests ===
1385 struct PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD;
1386
1387 //=== VK_KHR_fragment_shader_barycentric ===
1388 struct PhysicalDeviceFragmentShaderBarycentricFeaturesKHR;
1389 using PhysicalDeviceFragmentShaderBarycentricFeaturesNV = PhysicalDeviceFragmentShaderBarycentricFeaturesKHR;
1390 struct PhysicalDeviceFragmentShaderBarycentricPropertiesKHR;
1391
1392 //=== VK_KHR_shader_subgroup_uniform_control_flow ===
1393 struct PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR;
1394
1395 //=== VK_NV_fragment_shading_rate_enums ===
1396 struct PhysicalDeviceFragmentShadingRateEnumsFeaturesNV;
1397 struct PhysicalDeviceFragmentShadingRateEnumsPropertiesNV;
1398 struct PipelineFragmentShadingRateEnumStateCreateInfoNV;
1399
1400 //=== VK_NV_ray_tracing_motion_blur ===
1401 struct AccelerationStructureGeometryMotionTrianglesDataNV;
1402 struct AccelerationStructureMotionInfoNV;
1403 struct AccelerationStructureMotionInstanceNV;
1404 union AccelerationStructureMotionInstanceDataNV;
1405 struct AccelerationStructureMatrixMotionInstanceNV;
1406 struct AccelerationStructureSRTMotionInstanceNV;
1407 struct SRTDataNV;
1408 struct PhysicalDeviceRayTracingMotionBlurFeaturesNV;
1409
1410 //=== VK_EXT_mesh_shader ===
1411 struct PhysicalDeviceMeshShaderFeaturesEXT;
1412 struct PhysicalDeviceMeshShaderPropertiesEXT;
1413 struct DrawMeshTasksIndirectCommandEXT;
1414
1415 //=== VK_EXT_ycbcr_2plane_444_formats ===
1416 struct PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT;
1417
1418 //=== VK_EXT_fragment_density_map2 ===
1419 struct PhysicalDeviceFragmentDensityMap2FeaturesEXT;
1420 struct PhysicalDeviceFragmentDensityMap2PropertiesEXT;
1421
1422 //=== VK_QCOM_rotated_copy_commands ===
1423 struct CopyCommandTransformInfoQCOM;
1424
1425 //=== VK_KHR_workgroup_memory_explicit_layout ===
1426 struct PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR;
1427
1428 //=== VK_EXT_image_compression_control ===
1429 struct PhysicalDeviceImageCompressionControlFeaturesEXT;
1430 struct ImageCompressionControlEXT;
1431 struct ImageCompressionPropertiesEXT;
1432
1433 //=== VK_EXT_attachment_feedback_loop_layout ===
1434 struct PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT;
1435
1436 //=== VK_EXT_4444_formats ===
1437 struct PhysicalDevice4444FormatsFeaturesEXT;
1438
1439 //=== VK_EXT_device_fault ===
1440 struct PhysicalDeviceFaultFeaturesEXT;
1441 struct DeviceFaultCountsEXT;
1442 struct DeviceFaultInfoEXT;
1443 struct DeviceFaultAddressInfoEXT;
1444 struct DeviceFaultVendorInfoEXT;
1445 struct DeviceFaultVendorBinaryHeaderVersionOneEXT;
1446
1447 //=== VK_EXT_rgba10x6_formats ===
1448 struct PhysicalDeviceRGBA10X6FormatsFeaturesEXT;
1449
1450 #if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
1451 //=== VK_EXT_directfb_surface ===
1452 struct DirectFBSurfaceCreateInfoEXT;
1453 #endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
1454
1455 //=== VK_EXT_vertex_input_dynamic_state ===
1456 struct PhysicalDeviceVertexInputDynamicStateFeaturesEXT;
1457 struct VertexInputBindingDescription2EXT;
1458 struct VertexInputAttributeDescription2EXT;
1459
1460 //=== VK_EXT_physical_device_drm ===
1461 struct PhysicalDeviceDrmPropertiesEXT;
1462
1463 //=== VK_EXT_device_address_binding_report ===
1464 struct PhysicalDeviceAddressBindingReportFeaturesEXT;
1465 struct DeviceAddressBindingCallbackDataEXT;
1466
1467 //=== VK_EXT_depth_clip_control ===
1468 struct PhysicalDeviceDepthClipControlFeaturesEXT;
1469 struct PipelineViewportDepthClipControlCreateInfoEXT;
1470
1471 //=== VK_EXT_primitive_topology_list_restart ===
1472 struct PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT;
1473
1474 #if defined( VK_USE_PLATFORM_FUCHSIA )
1475 //=== VK_FUCHSIA_external_memory ===
1476 struct ImportMemoryZirconHandleInfoFUCHSIA;
1477 struct MemoryZirconHandlePropertiesFUCHSIA;
1478 struct MemoryGetZirconHandleInfoFUCHSIA;
1479 #endif /*VK_USE_PLATFORM_FUCHSIA*/
1480
1481 #if defined( VK_USE_PLATFORM_FUCHSIA )
1482 //=== VK_FUCHSIA_external_semaphore ===
1483 struct ImportSemaphoreZirconHandleInfoFUCHSIA;
1484 struct SemaphoreGetZirconHandleInfoFUCHSIA;
1485 #endif /*VK_USE_PLATFORM_FUCHSIA*/
1486
1487 #if defined( VK_USE_PLATFORM_FUCHSIA )
1488 //=== VK_FUCHSIA_buffer_collection ===
1489 struct BufferCollectionCreateInfoFUCHSIA;
1490 struct ImportMemoryBufferCollectionFUCHSIA;
1491 struct BufferCollectionImageCreateInfoFUCHSIA;
1492 struct BufferConstraintsInfoFUCHSIA;
1493 struct BufferCollectionBufferCreateInfoFUCHSIA;
1494 struct BufferCollectionPropertiesFUCHSIA;
1495 struct SysmemColorSpaceFUCHSIA;
1496 struct ImageConstraintsInfoFUCHSIA;
1497 struct ImageFormatConstraintsInfoFUCHSIA;
1498 struct BufferCollectionConstraintsInfoFUCHSIA;
1499 #endif /*VK_USE_PLATFORM_FUCHSIA*/
1500
1501 //=== VK_HUAWEI_subpass_shading ===
1502 struct SubpassShadingPipelineCreateInfoHUAWEI;
1503 struct PhysicalDeviceSubpassShadingFeaturesHUAWEI;
1504 struct PhysicalDeviceSubpassShadingPropertiesHUAWEI;
1505
1506 //=== VK_HUAWEI_invocation_mask ===
1507 struct PhysicalDeviceInvocationMaskFeaturesHUAWEI;
1508
1509 //=== VK_NV_external_memory_rdma ===
1510 struct MemoryGetRemoteAddressInfoNV;
1511 struct PhysicalDeviceExternalMemoryRDMAFeaturesNV;
1512
1513 //=== VK_EXT_pipeline_properties ===
1514 struct PipelinePropertiesIdentifierEXT;
1515 struct PhysicalDevicePipelinePropertiesFeaturesEXT;
1516
1517 //=== VK_EXT_frame_boundary ===
1518 struct PhysicalDeviceFrameBoundaryFeaturesEXT;
1519 struct FrameBoundaryEXT;
1520
1521 //=== VK_EXT_multisampled_render_to_single_sampled ===
1522 struct PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT;
1523 struct SubpassResolvePerformanceQueryEXT;
1524 struct MultisampledRenderToSingleSampledInfoEXT;
1525
1526 //=== VK_EXT_extended_dynamic_state2 ===
1527 struct PhysicalDeviceExtendedDynamicState2FeaturesEXT;
1528
1529 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
1530 //=== VK_QNX_screen_surface ===
1531 struct ScreenSurfaceCreateInfoQNX;
1532 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
1533
1534 //=== VK_EXT_color_write_enable ===
1535 struct PhysicalDeviceColorWriteEnableFeaturesEXT;
1536 struct PipelineColorWriteCreateInfoEXT;
1537
1538 //=== VK_EXT_primitives_generated_query ===
1539 struct PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT;
1540
1541 //=== VK_KHR_ray_tracing_maintenance1 ===
1542 struct PhysicalDeviceRayTracingMaintenance1FeaturesKHR;
1543 struct TraceRaysIndirectCommand2KHR;
1544
1545 //=== VK_KHR_shader_untyped_pointers ===
1546 struct PhysicalDeviceShaderUntypedPointersFeaturesKHR;
1547
1548 //=== VK_VALVE_video_encode_rgb_conversion ===
1549 struct PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE;
1550 struct VideoEncodeRgbConversionCapabilitiesVALVE;
1551 struct VideoEncodeProfileRgbConversionInfoVALVE;
1552 struct VideoEncodeSessionRgbConversionCreateInfoVALVE;
1553
1554 //=== VK_EXT_image_view_min_lod ===
1555 struct PhysicalDeviceImageViewMinLodFeaturesEXT;
1556 struct ImageViewMinLodCreateInfoEXT;
1557
1558 //=== VK_EXT_multi_draw ===
1559 struct PhysicalDeviceMultiDrawFeaturesEXT;
1560 struct PhysicalDeviceMultiDrawPropertiesEXT;
1561 struct MultiDrawInfoEXT;
1562 struct MultiDrawIndexedInfoEXT;
1563
1564 //=== VK_EXT_image_2d_view_of_3d ===
1565 struct PhysicalDeviceImage2DViewOf3DFeaturesEXT;
1566
1567 //=== VK_EXT_shader_tile_image ===
1568 struct PhysicalDeviceShaderTileImageFeaturesEXT;
1569 struct PhysicalDeviceShaderTileImagePropertiesEXT;
1570
1571 //=== VK_EXT_opacity_micromap ===
1572 struct MicromapBuildInfoEXT;
1573 struct MicromapUsageEXT;
1574 struct MicromapCreateInfoEXT;
1575 struct PhysicalDeviceOpacityMicromapFeaturesEXT;
1576 struct PhysicalDeviceOpacityMicromapPropertiesEXT;
1577 struct MicromapVersionInfoEXT;
1578 struct CopyMicromapToMemoryInfoEXT;
1579 struct CopyMemoryToMicromapInfoEXT;
1580 struct CopyMicromapInfoEXT;
1581 struct MicromapBuildSizesInfoEXT;
1582 struct AccelerationStructureTrianglesOpacityMicromapEXT;
1583 struct MicromapTriangleEXT;
1584
1585 #if defined( VK_ENABLE_BETA_EXTENSIONS )
1586 //=== VK_NV_displacement_micromap ===
1587 struct PhysicalDeviceDisplacementMicromapFeaturesNV;
1588 struct PhysicalDeviceDisplacementMicromapPropertiesNV;
1589 struct AccelerationStructureTrianglesDisplacementMicromapNV;
1590 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
1591
1592 //=== VK_HUAWEI_cluster_culling_shader ===
1593 struct PhysicalDeviceClusterCullingShaderFeaturesHUAWEI;
1594 struct PhysicalDeviceClusterCullingShaderPropertiesHUAWEI;
1595 struct PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI;
1596
1597 //=== VK_EXT_border_color_swizzle ===
1598 struct PhysicalDeviceBorderColorSwizzleFeaturesEXT;
1599 struct SamplerBorderColorComponentMappingCreateInfoEXT;
1600
1601 //=== VK_EXT_pageable_device_local_memory ===
1602 struct PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT;
1603
1604 //=== VK_ARM_shader_core_properties ===
1605 struct PhysicalDeviceShaderCorePropertiesARM;
1606
1607 //=== VK_ARM_scheduling_controls ===
1608 struct DeviceQueueShaderCoreControlCreateInfoARM;
1609 struct PhysicalDeviceSchedulingControlsFeaturesARM;
1610 struct PhysicalDeviceSchedulingControlsPropertiesARM;
1611
1612 //=== VK_EXT_image_sliced_view_of_3d ===
1613 struct PhysicalDeviceImageSlicedViewOf3DFeaturesEXT;
1614 struct ImageViewSlicedCreateInfoEXT;
1615
1616 //=== VK_VALVE_descriptor_set_host_mapping ===
1617 struct PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE;
1618 struct DescriptorSetBindingReferenceVALVE;
1619 struct DescriptorSetLayoutHostMappingInfoVALVE;
1620
1621 //=== VK_EXT_non_seamless_cube_map ===
1622 struct PhysicalDeviceNonSeamlessCubeMapFeaturesEXT;
1623
1624 //=== VK_ARM_render_pass_striped ===
1625 struct PhysicalDeviceRenderPassStripedFeaturesARM;
1626 struct PhysicalDeviceRenderPassStripedPropertiesARM;
1627 struct RenderPassStripeBeginInfoARM;
1628 struct RenderPassStripeInfoARM;
1629 struct RenderPassStripeSubmitInfoARM;
1630
1631 //=== VK_NV_copy_memory_indirect ===
1632 struct PhysicalDeviceCopyMemoryIndirectFeaturesNV;
1633
1634 //=== VK_NV_memory_decompression ===
1635 struct DecompressMemoryRegionNV;
1636
1637 //=== VK_NV_device_generated_commands_compute ===
1638 struct PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV;
1639 struct ComputePipelineIndirectBufferInfoNV;
1640 struct PipelineIndirectDeviceAddressInfoNV;
1641 struct BindPipelineIndirectCommandNV;
1642
1643 //=== VK_NV_ray_tracing_linear_swept_spheres ===
1644 struct PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV;
1645 struct AccelerationStructureGeometryLinearSweptSpheresDataNV;
1646 struct AccelerationStructureGeometrySpheresDataNV;
1647
1648 //=== VK_NV_linear_color_attachment ===
1649 struct PhysicalDeviceLinearColorAttachmentFeaturesNV;
1650
1651 //=== VK_KHR_shader_maximal_reconvergence ===
1652 struct PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR;
1653
1654 //=== VK_EXT_image_compression_control_swapchain ===
1655 struct PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT;
1656
1657 //=== VK_QCOM_image_processing ===
1658 struct ImageViewSampleWeightCreateInfoQCOM;
1659 struct PhysicalDeviceImageProcessingFeaturesQCOM;
1660 struct PhysicalDeviceImageProcessingPropertiesQCOM;
1661
1662 //=== VK_EXT_nested_command_buffer ===
1663 struct PhysicalDeviceNestedCommandBufferFeaturesEXT;
1664 struct PhysicalDeviceNestedCommandBufferPropertiesEXT;
1665
1666 #if defined( VK_USE_PLATFORM_OHOS )
1667 //=== VK_OHOS_external_memory ===
1668 struct NativeBufferUsageOHOS;
1669 struct NativeBufferPropertiesOHOS;
1670 struct NativeBufferFormatPropertiesOHOS;
1671 struct ImportNativeBufferInfoOHOS;
1672 struct MemoryGetNativeBufferInfoOHOS;
1673 struct ExternalFormatOHOS;
1674 #endif /*VK_USE_PLATFORM_OHOS*/
1675
1676 //=== VK_EXT_external_memory_acquire_unmodified ===
1677 struct ExternalMemoryAcquireUnmodifiedEXT;
1678
1679 //=== VK_EXT_extended_dynamic_state3 ===
1680 struct PhysicalDeviceExtendedDynamicState3FeaturesEXT;
1681 struct PhysicalDeviceExtendedDynamicState3PropertiesEXT;
1682 struct ColorBlendEquationEXT;
1683 struct ColorBlendAdvancedEXT;
1684
1685 //=== VK_EXT_subpass_merge_feedback ===
1686 struct PhysicalDeviceSubpassMergeFeedbackFeaturesEXT;
1687 struct RenderPassCreationControlEXT;
1688 struct RenderPassCreationFeedbackInfoEXT;
1689 struct RenderPassCreationFeedbackCreateInfoEXT;
1690 struct RenderPassSubpassFeedbackInfoEXT;
1691 struct RenderPassSubpassFeedbackCreateInfoEXT;
1692
1693 //=== VK_LUNARG_direct_driver_loading ===
1694 struct DirectDriverLoadingInfoLUNARG;
1695 struct DirectDriverLoadingListLUNARG;
1696
1697 //=== VK_ARM_tensors ===
1698 struct TensorDescriptionARM;
1699 struct TensorCreateInfoARM;
1700 struct TensorViewCreateInfoARM;
1701 struct TensorMemoryRequirementsInfoARM;
1702 struct BindTensorMemoryInfoARM;
1703 struct WriteDescriptorSetTensorARM;
1704 struct TensorFormatPropertiesARM;
1705 struct PhysicalDeviceTensorPropertiesARM;
1706 struct TensorMemoryBarrierARM;
1707 struct TensorDependencyInfoARM;
1708 struct PhysicalDeviceTensorFeaturesARM;
1709 struct DeviceTensorMemoryRequirementsARM;
1710 struct CopyTensorInfoARM;
1711 struct TensorCopyARM;
1712 struct MemoryDedicatedAllocateInfoTensorARM;
1713 struct PhysicalDeviceExternalTensorInfoARM;
1714 struct ExternalTensorPropertiesARM;
1715 struct ExternalMemoryTensorCreateInfoARM;
1716 struct PhysicalDeviceDescriptorBufferTensorFeaturesARM;
1717 struct PhysicalDeviceDescriptorBufferTensorPropertiesARM;
1718 struct DescriptorGetTensorInfoARM;
1719 struct TensorCaptureDescriptorDataInfoARM;
1720 struct TensorViewCaptureDescriptorDataInfoARM;
1721 struct FrameBoundaryTensorsARM;
1722
1723 //=== VK_EXT_shader_module_identifier ===
1724 struct PhysicalDeviceShaderModuleIdentifierFeaturesEXT;
1725 struct PhysicalDeviceShaderModuleIdentifierPropertiesEXT;
1726 struct PipelineShaderStageModuleIdentifierCreateInfoEXT;
1727 struct ShaderModuleIdentifierEXT;
1728
1729 //=== VK_EXT_rasterization_order_attachment_access ===
1730 struct PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT;
1731 using PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM = PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT;
1732
1733 //=== VK_NV_optical_flow ===
1734 struct PhysicalDeviceOpticalFlowFeaturesNV;
1735 struct PhysicalDeviceOpticalFlowPropertiesNV;
1736 struct OpticalFlowImageFormatInfoNV;
1737 struct OpticalFlowImageFormatPropertiesNV;
1738 struct OpticalFlowSessionCreateInfoNV;
1739 struct OpticalFlowSessionCreatePrivateDataInfoNV;
1740 struct OpticalFlowExecuteInfoNV;
1741
1742 //=== VK_EXT_legacy_dithering ===
1743 struct PhysicalDeviceLegacyDitheringFeaturesEXT;
1744
1745 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
1746 //=== VK_ANDROID_external_format_resolve ===
1747 struct PhysicalDeviceExternalFormatResolveFeaturesANDROID;
1748 struct PhysicalDeviceExternalFormatResolvePropertiesANDROID;
1749 struct AndroidHardwareBufferFormatResolvePropertiesANDROID;
1750 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
1751
1752 //=== VK_AMD_anti_lag ===
1753 struct PhysicalDeviceAntiLagFeaturesAMD;
1754 struct AntiLagDataAMD;
1755 struct AntiLagPresentationInfoAMD;
1756
1757 #if defined( VK_ENABLE_BETA_EXTENSIONS )
1758 //=== VK_AMDX_dense_geometry_format ===
1759 struct PhysicalDeviceDenseGeometryFormatFeaturesAMDX;
1760 struct AccelerationStructureDenseGeometryFormatTrianglesDataAMDX;
1761 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
1762
1763 //=== VK_KHR_present_id2 ===
1764 struct SurfaceCapabilitiesPresentId2KHR;
1765 struct PresentId2KHR;
1766 struct PhysicalDevicePresentId2FeaturesKHR;
1767
1768 //=== VK_KHR_present_wait2 ===
1769 struct SurfaceCapabilitiesPresentWait2KHR;
1770 struct PhysicalDevicePresentWait2FeaturesKHR;
1771 struct PresentWait2InfoKHR;
1772
1773 //=== VK_KHR_ray_tracing_position_fetch ===
1774 struct PhysicalDeviceRayTracingPositionFetchFeaturesKHR;
1775
1776 //=== VK_EXT_shader_object ===
1777 struct PhysicalDeviceShaderObjectFeaturesEXT;
1778 struct PhysicalDeviceShaderObjectPropertiesEXT;
1779 struct ShaderCreateInfoEXT;
1780
1781 //=== VK_KHR_pipeline_binary ===
1782 struct PhysicalDevicePipelineBinaryFeaturesKHR;
1783 struct PhysicalDevicePipelineBinaryPropertiesKHR;
1784 struct DevicePipelineBinaryInternalCacheControlKHR;
1785 struct PipelineBinaryKeyKHR;
1786 struct PipelineBinaryDataKHR;
1787 struct PipelineBinaryKeysAndDataKHR;
1788 struct PipelineBinaryCreateInfoKHR;
1789 struct PipelineBinaryInfoKHR;
1790 struct ReleaseCapturedPipelineDataInfoKHR;
1791 struct PipelineBinaryDataInfoKHR;
1792 struct PipelineCreateInfoKHR;
1793 struct PipelineBinaryHandlesInfoKHR;
1794
1795 //=== VK_QCOM_tile_properties ===
1796 struct PhysicalDeviceTilePropertiesFeaturesQCOM;
1797 struct TilePropertiesQCOM;
1798
1799 //=== VK_SEC_amigo_profiling ===
1800 struct PhysicalDeviceAmigoProfilingFeaturesSEC;
1801 struct AmigoProfilingSubmitInfoSEC;
1802
1803 //=== VK_KHR_surface_maintenance1 ===
1804 struct SurfacePresentModeKHR;
1805 using SurfacePresentModeEXT = SurfacePresentModeKHR;
1806 struct SurfacePresentScalingCapabilitiesKHR;
1807 using SurfacePresentScalingCapabilitiesEXT = SurfacePresentScalingCapabilitiesKHR;
1808 struct SurfacePresentModeCompatibilityKHR;
1809 using SurfacePresentModeCompatibilityEXT = SurfacePresentModeCompatibilityKHR;
1810
1811 //=== VK_KHR_swapchain_maintenance1 ===
1812 struct PhysicalDeviceSwapchainMaintenance1FeaturesKHR;
1813 using PhysicalDeviceSwapchainMaintenance1FeaturesEXT = PhysicalDeviceSwapchainMaintenance1FeaturesKHR;
1814 struct SwapchainPresentFenceInfoKHR;
1815 using SwapchainPresentFenceInfoEXT = SwapchainPresentFenceInfoKHR;
1816 struct SwapchainPresentModesCreateInfoKHR;
1817 using SwapchainPresentModesCreateInfoEXT = SwapchainPresentModesCreateInfoKHR;
1818 struct SwapchainPresentModeInfoKHR;
1819 using SwapchainPresentModeInfoEXT = SwapchainPresentModeInfoKHR;
1820 struct SwapchainPresentScalingCreateInfoKHR;
1821 using SwapchainPresentScalingCreateInfoEXT = SwapchainPresentScalingCreateInfoKHR;
1822 struct ReleaseSwapchainImagesInfoKHR;
1823 using ReleaseSwapchainImagesInfoEXT = ReleaseSwapchainImagesInfoKHR;
1824
1825 //=== VK_QCOM_multiview_per_view_viewports ===
1826 struct PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM;
1827
1828 //=== VK_NV_ray_tracing_invocation_reorder ===
1829 struct PhysicalDeviceRayTracingInvocationReorderPropertiesNV;
1830 struct PhysicalDeviceRayTracingInvocationReorderFeaturesNV;
1831
1832 //=== VK_NV_cooperative_vector ===
1833 struct PhysicalDeviceCooperativeVectorPropertiesNV;
1834 struct PhysicalDeviceCooperativeVectorFeaturesNV;
1835 struct CooperativeVectorPropertiesNV;
1836 struct ConvertCooperativeVectorMatrixInfoNV;
1837
1838 //=== VK_NV_extended_sparse_address_space ===
1839 struct PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV;
1840 struct PhysicalDeviceExtendedSparseAddressSpacePropertiesNV;
1841
1842 //=== VK_EXT_mutable_descriptor_type ===
1843 struct PhysicalDeviceMutableDescriptorTypeFeaturesEXT;
1844 using PhysicalDeviceMutableDescriptorTypeFeaturesVALVE = PhysicalDeviceMutableDescriptorTypeFeaturesEXT;
1845 struct MutableDescriptorTypeListEXT;
1846 using MutableDescriptorTypeListVALVE = MutableDescriptorTypeListEXT;
1847 struct MutableDescriptorTypeCreateInfoEXT;
1848 using MutableDescriptorTypeCreateInfoVALVE = MutableDescriptorTypeCreateInfoEXT;
1849
1850 //=== VK_EXT_legacy_vertex_attributes ===
1851 struct PhysicalDeviceLegacyVertexAttributesFeaturesEXT;
1852 struct PhysicalDeviceLegacyVertexAttributesPropertiesEXT;
1853
1854 //=== VK_EXT_layer_settings ===
1855 struct LayerSettingsCreateInfoEXT;
1856 struct LayerSettingEXT;
1857
1858 //=== VK_ARM_shader_core_builtins ===
1859 struct PhysicalDeviceShaderCoreBuiltinsFeaturesARM;
1860 struct PhysicalDeviceShaderCoreBuiltinsPropertiesARM;
1861
1862 //=== VK_EXT_pipeline_library_group_handles ===
1863 struct PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT;
1864
1865 //=== VK_EXT_dynamic_rendering_unused_attachments ===
1866 struct PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT;
1867
1868 //=== VK_NV_low_latency2 ===
1869 struct LatencySleepModeInfoNV;
1870 struct LatencySleepInfoNV;
1871 struct SetLatencyMarkerInfoNV;
1872 struct GetLatencyMarkerInfoNV;
1873 struct LatencyTimingsFrameReportNV;
1874 struct LatencySubmissionPresentIdNV;
1875 struct SwapchainLatencyCreateInfoNV;
1876 struct OutOfBandQueueTypeInfoNV;
1877 struct LatencySurfaceCapabilitiesNV;
1878
1879 //=== VK_KHR_cooperative_matrix ===
1880 struct CooperativeMatrixPropertiesKHR;
1881 struct PhysicalDeviceCooperativeMatrixFeaturesKHR;
1882 struct PhysicalDeviceCooperativeMatrixPropertiesKHR;
1883
1884 //=== VK_ARM_data_graph ===
1885 struct PhysicalDeviceDataGraphFeaturesARM;
1886 struct DataGraphPipelineConstantARM;
1887 struct DataGraphPipelineResourceInfoARM;
1888 struct DataGraphPipelineCompilerControlCreateInfoARM;
1889 struct DataGraphPipelineCreateInfoARM;
1890 struct DataGraphPipelineShaderModuleCreateInfoARM;
1891 struct DataGraphPipelineSessionCreateInfoARM;
1892 struct DataGraphPipelineSessionBindPointRequirementsInfoARM;
1893 struct DataGraphPipelineSessionBindPointRequirementARM;
1894 struct DataGraphPipelineSessionMemoryRequirementsInfoARM;
1895 struct BindDataGraphPipelineSessionMemoryInfoARM;
1896 struct DataGraphPipelineInfoARM;
1897 struct DataGraphPipelinePropertyQueryResultARM;
1898 struct DataGraphPipelineIdentifierCreateInfoARM;
1899 struct DataGraphPipelineDispatchInfoARM;
1900 struct PhysicalDeviceDataGraphProcessingEngineARM;
1901 struct QueueFamilyDataGraphPropertiesARM;
1902 struct DataGraphProcessingEngineCreateInfoARM;
1903 struct PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM;
1904 struct QueueFamilyDataGraphProcessingEnginePropertiesARM;
1905 struct PhysicalDeviceDataGraphOperationSupportARM;
1906 struct DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM;
1907
1908 //=== VK_QCOM_multiview_per_view_render_areas ===
1909 struct PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM;
1910 struct MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM;
1911
1912 //=== VK_KHR_compute_shader_derivatives ===
1913 struct PhysicalDeviceComputeShaderDerivativesFeaturesKHR;
1914 using PhysicalDeviceComputeShaderDerivativesFeaturesNV = PhysicalDeviceComputeShaderDerivativesFeaturesKHR;
1915 struct PhysicalDeviceComputeShaderDerivativesPropertiesKHR;
1916
1917 //=== VK_KHR_video_decode_av1 ===
1918 struct VideoDecodeAV1ProfileInfoKHR;
1919 struct VideoDecodeAV1CapabilitiesKHR;
1920 struct VideoDecodeAV1SessionParametersCreateInfoKHR;
1921 struct VideoDecodeAV1PictureInfoKHR;
1922 struct VideoDecodeAV1DpbSlotInfoKHR;
1923
1924 //=== VK_KHR_video_encode_av1 ===
1925 struct PhysicalDeviceVideoEncodeAV1FeaturesKHR;
1926 struct VideoEncodeAV1CapabilitiesKHR;
1927 struct VideoEncodeAV1QualityLevelPropertiesKHR;
1928 struct VideoEncodeAV1SessionCreateInfoKHR;
1929 struct VideoEncodeAV1SessionParametersCreateInfoKHR;
1930 struct VideoEncodeAV1PictureInfoKHR;
1931 struct VideoEncodeAV1DpbSlotInfoKHR;
1932 struct VideoEncodeAV1ProfileInfoKHR;
1933 struct VideoEncodeAV1QIndexKHR;
1934 struct VideoEncodeAV1FrameSizeKHR;
1935 struct VideoEncodeAV1GopRemainingFrameInfoKHR;
1936 struct VideoEncodeAV1RateControlInfoKHR;
1937 struct VideoEncodeAV1RateControlLayerInfoKHR;
1938
1939 //=== VK_KHR_video_decode_vp9 ===
1940 struct PhysicalDeviceVideoDecodeVP9FeaturesKHR;
1941 struct VideoDecodeVP9ProfileInfoKHR;
1942 struct VideoDecodeVP9CapabilitiesKHR;
1943 struct VideoDecodeVP9PictureInfoKHR;
1944
1945 //=== VK_KHR_video_maintenance1 ===
1946 struct PhysicalDeviceVideoMaintenance1FeaturesKHR;
1947 struct VideoInlineQueryInfoKHR;
1948
1949 //=== VK_NV_per_stage_descriptor_set ===
1950 struct PhysicalDevicePerStageDescriptorSetFeaturesNV;
1951
1952 //=== VK_QCOM_image_processing2 ===
1953 struct PhysicalDeviceImageProcessing2FeaturesQCOM;
1954 struct PhysicalDeviceImageProcessing2PropertiesQCOM;
1955 struct SamplerBlockMatchWindowCreateInfoQCOM;
1956
1957 //=== VK_QCOM_filter_cubic_weights ===
1958 struct PhysicalDeviceCubicWeightsFeaturesQCOM;
1959 struct SamplerCubicWeightsCreateInfoQCOM;
1960 struct BlitImageCubicWeightsInfoQCOM;
1961
1962 //=== VK_QCOM_ycbcr_degamma ===
1963 struct PhysicalDeviceYcbcrDegammaFeaturesQCOM;
1964 struct SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM;
1965
1966 //=== VK_QCOM_filter_cubic_clamp ===
1967 struct PhysicalDeviceCubicClampFeaturesQCOM;
1968
1969 //=== VK_EXT_attachment_feedback_loop_dynamic_state ===
1970 struct PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT;
1971
1972 //=== VK_KHR_unified_image_layouts ===
1973 struct PhysicalDeviceUnifiedImageLayoutsFeaturesKHR;
1974 struct AttachmentFeedbackLoopInfoEXT;
1975
1976 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
1977 //=== VK_QNX_external_memory_screen_buffer ===
1978 struct ScreenBufferPropertiesQNX;
1979 struct ScreenBufferFormatPropertiesQNX;
1980 struct ImportScreenBufferInfoQNX;
1981 struct ExternalFormatQNX;
1982 struct PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX;
1983 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
1984
1985 //=== VK_MSFT_layered_driver ===
1986 struct PhysicalDeviceLayeredDriverPropertiesMSFT;
1987
1988 //=== VK_KHR_calibrated_timestamps ===
1989 struct CalibratedTimestampInfoKHR;
1990 using CalibratedTimestampInfoEXT = CalibratedTimestampInfoKHR;
1991
1992 //=== VK_KHR_maintenance6 ===
1993 struct SetDescriptorBufferOffsetsInfoEXT;
1994 struct BindDescriptorBufferEmbeddedSamplersInfoEXT;
1995
1996 //=== VK_NV_descriptor_pool_overallocation ===
1997 struct PhysicalDeviceDescriptorPoolOverallocationFeaturesNV;
1998
1999 //=== VK_QCOM_tile_memory_heap ===
2000 struct PhysicalDeviceTileMemoryHeapFeaturesQCOM;
2001 struct PhysicalDeviceTileMemoryHeapPropertiesQCOM;
2002 struct TileMemoryRequirementsQCOM;
2003 struct TileMemoryBindInfoQCOM;
2004 struct TileMemorySizeInfoQCOM;
2005
2006 //=== VK_KHR_copy_memory_indirect ===
2007 struct StridedDeviceAddressRangeKHR;
2008 struct CopyMemoryIndirectCommandKHR;
2009 using CopyMemoryIndirectCommandNV = CopyMemoryIndirectCommandKHR;
2010 struct CopyMemoryIndirectInfoKHR;
2011 struct CopyMemoryToImageIndirectCommandKHR;
2012 using CopyMemoryToImageIndirectCommandNV = CopyMemoryToImageIndirectCommandKHR;
2013 struct CopyMemoryToImageIndirectInfoKHR;
2014 struct PhysicalDeviceCopyMemoryIndirectFeaturesKHR;
2015 struct PhysicalDeviceCopyMemoryIndirectPropertiesKHR;
2016 using PhysicalDeviceCopyMemoryIndirectPropertiesNV = PhysicalDeviceCopyMemoryIndirectPropertiesKHR;
2017
2018 //=== VK_EXT_memory_decompression ===
2019 struct DecompressMemoryInfoEXT;
2020 struct DecompressMemoryRegionEXT;
2021 struct PhysicalDeviceMemoryDecompressionFeaturesEXT;
2022 using PhysicalDeviceMemoryDecompressionFeaturesNV = PhysicalDeviceMemoryDecompressionFeaturesEXT;
2023 struct PhysicalDeviceMemoryDecompressionPropertiesEXT;
2024 using PhysicalDeviceMemoryDecompressionPropertiesNV = PhysicalDeviceMemoryDecompressionPropertiesEXT;
2025
2026 //=== VK_NV_display_stereo ===
2027 struct DisplaySurfaceStereoCreateInfoNV;
2028 struct DisplayModeStereoPropertiesNV;
2029
2030 //=== VK_KHR_video_encode_intra_refresh ===
2031 struct VideoEncodeIntraRefreshCapabilitiesKHR;
2032 struct VideoEncodeSessionIntraRefreshCreateInfoKHR;
2033 struct VideoEncodeIntraRefreshInfoKHR;
2034 struct VideoReferenceIntraRefreshInfoKHR;
2035 struct PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR;
2036
2037 //=== VK_KHR_video_encode_quantization_map ===
2038 struct VideoEncodeQuantizationMapCapabilitiesKHR;
2039 struct VideoFormatQuantizationMapPropertiesKHR;
2040 struct VideoEncodeQuantizationMapInfoKHR;
2041 struct VideoEncodeQuantizationMapSessionParametersCreateInfoKHR;
2042 struct PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR;
2043 struct VideoEncodeH264QuantizationMapCapabilitiesKHR;
2044 struct VideoEncodeH265QuantizationMapCapabilitiesKHR;
2045 struct VideoFormatH265QuantizationMapPropertiesKHR;
2046 struct VideoEncodeAV1QuantizationMapCapabilitiesKHR;
2047 struct VideoFormatAV1QuantizationMapPropertiesKHR;
2048
2049 //=== VK_NV_raw_access_chains ===
2050 struct PhysicalDeviceRawAccessChainsFeaturesNV;
2051
2052 //=== VK_NV_external_compute_queue ===
2053 struct ExternalComputeQueueDeviceCreateInfoNV;
2054 struct ExternalComputeQueueCreateInfoNV;
2055 struct ExternalComputeQueueDataParamsNV;
2056 struct PhysicalDeviceExternalComputeQueuePropertiesNV;
2057
2058 //=== VK_KHR_shader_relaxed_extended_instruction ===
2059 struct PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR;
2060
2061 //=== VK_NV_command_buffer_inheritance ===
2062 struct PhysicalDeviceCommandBufferInheritanceFeaturesNV;
2063
2064 //=== VK_KHR_maintenance7 ===
2065 struct PhysicalDeviceMaintenance7FeaturesKHR;
2066 struct PhysicalDeviceMaintenance7PropertiesKHR;
2067 struct PhysicalDeviceLayeredApiPropertiesListKHR;
2068 struct PhysicalDeviceLayeredApiPropertiesKHR;
2069 struct PhysicalDeviceLayeredApiVulkanPropertiesKHR;
2070
2071 //=== VK_NV_shader_atomic_float16_vector ===
2072 struct PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV;
2073
2074 //=== VK_EXT_shader_replicated_composites ===
2075 struct PhysicalDeviceShaderReplicatedCompositesFeaturesEXT;
2076
2077 //=== VK_EXT_shader_float8 ===
2078 struct PhysicalDeviceShaderFloat8FeaturesEXT;
2079
2080 //=== VK_NV_ray_tracing_validation ===
2081 struct PhysicalDeviceRayTracingValidationFeaturesNV;
2082
2083 //=== VK_NV_cluster_acceleration_structure ===
2084 struct PhysicalDeviceClusterAccelerationStructureFeaturesNV;
2085 struct PhysicalDeviceClusterAccelerationStructurePropertiesNV;
2086 struct ClusterAccelerationStructureClustersBottomLevelInputNV;
2087 struct ClusterAccelerationStructureTriangleClusterInputNV;
2088 struct ClusterAccelerationStructureMoveObjectsInputNV;
2089 union ClusterAccelerationStructureOpInputNV;
2090 struct ClusterAccelerationStructureInputInfoNV;
2091 struct ClusterAccelerationStructureCommandsInfoNV;
2092 struct StridedDeviceAddressNV;
2093 struct ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV;
2094 struct ClusterAccelerationStructureMoveObjectsInfoNV;
2095 struct ClusterAccelerationStructureBuildClustersBottomLevelInfoNV;
2096 struct ClusterAccelerationStructureBuildTriangleClusterInfoNV;
2097 struct ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV;
2098 struct ClusterAccelerationStructureInstantiateClusterInfoNV;
2099 struct ClusterAccelerationStructureGetTemplateIndicesInfoNV;
2100 struct RayTracingPipelineClusterAccelerationStructureCreateInfoNV;
2101
2102 //=== VK_NV_partitioned_acceleration_structure ===
2103 struct PhysicalDevicePartitionedAccelerationStructureFeaturesNV;
2104 struct PhysicalDevicePartitionedAccelerationStructurePropertiesNV;
2105 struct PartitionedAccelerationStructureFlagsNV;
2106 struct BuildPartitionedAccelerationStructureIndirectCommandNV;
2107 struct PartitionedAccelerationStructureWriteInstanceDataNV;
2108 struct PartitionedAccelerationStructureUpdateInstanceDataNV;
2109 struct PartitionedAccelerationStructureWritePartitionTranslationDataNV;
2110 struct WriteDescriptorSetPartitionedAccelerationStructureNV;
2111 struct PartitionedAccelerationStructureInstancesInputNV;
2112 struct BuildPartitionedAccelerationStructureInfoNV;
2113
2114 //=== VK_EXT_device_generated_commands ===
2115 struct PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT;
2116 struct PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT;
2117 struct GeneratedCommandsMemoryRequirementsInfoEXT;
2118 struct IndirectExecutionSetCreateInfoEXT;
2119 union IndirectExecutionSetInfoEXT;
2120 struct IndirectExecutionSetPipelineInfoEXT;
2121 struct IndirectExecutionSetShaderInfoEXT;
2122 struct GeneratedCommandsInfoEXT;
2123 struct WriteIndirectExecutionSetPipelineEXT;
2124 struct IndirectCommandsLayoutCreateInfoEXT;
2125 struct IndirectCommandsLayoutTokenEXT;
2126 struct DrawIndirectCountIndirectCommandEXT;
2127 struct IndirectCommandsVertexBufferTokenEXT;
2128 struct BindVertexBufferIndirectCommandEXT;
2129 struct IndirectCommandsIndexBufferTokenEXT;
2130 struct BindIndexBufferIndirectCommandEXT;
2131 struct IndirectCommandsPushConstantTokenEXT;
2132 struct IndirectCommandsExecutionSetTokenEXT;
2133 union IndirectCommandsTokenDataEXT;
2134 struct IndirectExecutionSetShaderLayoutInfoEXT;
2135 struct GeneratedCommandsPipelineInfoEXT;
2136 struct GeneratedCommandsShaderInfoEXT;
2137 struct WriteIndirectExecutionSetShaderEXT;
2138
2139 //=== VK_KHR_maintenance8 ===
2140 struct MemoryBarrierAccessFlags3KHR;
2141 struct PhysicalDeviceMaintenance8FeaturesKHR;
2142
2143 //=== VK_MESA_image_alignment_control ===
2144 struct PhysicalDeviceImageAlignmentControlFeaturesMESA;
2145 struct PhysicalDeviceImageAlignmentControlPropertiesMESA;
2146 struct ImageAlignmentControlCreateInfoMESA;
2147
2148 //=== VK_KHR_shader_fma ===
2149 struct PhysicalDeviceShaderFmaFeaturesKHR;
2150
2151 //=== VK_EXT_ray_tracing_invocation_reorder ===
2152 struct PhysicalDeviceRayTracingInvocationReorderPropertiesEXT;
2153 struct PhysicalDeviceRayTracingInvocationReorderFeaturesEXT;
2154
2155 //=== VK_EXT_depth_clamp_control ===
2156 struct PhysicalDeviceDepthClampControlFeaturesEXT;
2157 struct PipelineViewportDepthClampControlCreateInfoEXT;
2158 struct DepthClampRangeEXT;
2159
2160 //=== VK_KHR_maintenance9 ===
2161 struct PhysicalDeviceMaintenance9FeaturesKHR;
2162 struct PhysicalDeviceMaintenance9PropertiesKHR;
2163 struct QueueFamilyOwnershipTransferPropertiesKHR;
2164
2165 //=== VK_KHR_video_maintenance2 ===
2166 struct PhysicalDeviceVideoMaintenance2FeaturesKHR;
2167 struct VideoDecodeH264InlineSessionParametersInfoKHR;
2168 struct VideoDecodeH265InlineSessionParametersInfoKHR;
2169 struct VideoDecodeAV1InlineSessionParametersInfoKHR;
2170
2171 #if defined( VK_USE_PLATFORM_OHOS )
2172 //=== VK_OHOS_surface ===
2173 struct SurfaceCreateInfoOHOS;
2174 #endif /*VK_USE_PLATFORM_OHOS*/
2175
2176 #if defined( VK_USE_PLATFORM_OHOS )
2177 //=== VK_OHOS_native_buffer ===
2178 struct NativeBufferOHOS;
2179 struct SwapchainImageCreateInfoOHOS;
2180 struct PhysicalDevicePresentationPropertiesOHOS;
2181 #endif /*VK_USE_PLATFORM_OHOS*/
2182
2183 //=== VK_HUAWEI_hdr_vivid ===
2184 struct PhysicalDeviceHdrVividFeaturesHUAWEI;
2185 struct HdrVividDynamicMetadataHUAWEI;
2186
2187 //=== VK_NV_cooperative_matrix2 ===
2188 struct CooperativeMatrixFlexibleDimensionsPropertiesNV;
2189 struct PhysicalDeviceCooperativeMatrix2FeaturesNV;
2190 struct PhysicalDeviceCooperativeMatrix2PropertiesNV;
2191
2192 //=== VK_ARM_pipeline_opacity_micromap ===
2193 struct PhysicalDevicePipelineOpacityMicromapFeaturesARM;
2194
2195 #if defined( VK_USE_PLATFORM_METAL_EXT )
2196 //=== VK_EXT_external_memory_metal ===
2197 struct ImportMemoryMetalHandleInfoEXT;
2198 struct MemoryMetalHandlePropertiesEXT;
2199 struct MemoryGetMetalHandleInfoEXT;
2200 #endif /*VK_USE_PLATFORM_METAL_EXT*/
2201
2202 //=== VK_KHR_depth_clamp_zero_one ===
2203 struct PhysicalDeviceDepthClampZeroOneFeaturesKHR;
2204 using PhysicalDeviceDepthClampZeroOneFeaturesEXT = PhysicalDeviceDepthClampZeroOneFeaturesKHR;
2205
2206 //=== VK_ARM_performance_counters_by_region ===
2207 struct PhysicalDevicePerformanceCountersByRegionFeaturesARM;
2208 struct PhysicalDevicePerformanceCountersByRegionPropertiesARM;
2209 struct PerformanceCounterARM;
2210 struct PerformanceCounterDescriptionARM;
2211 struct RenderPassPerformanceCountersByRegionBeginInfoARM;
2212
2213 //=== VK_EXT_vertex_attribute_robustness ===
2214 struct PhysicalDeviceVertexAttributeRobustnessFeaturesEXT;
2215
2216 //=== VK_ARM_format_pack ===
2217 struct PhysicalDeviceFormatPackFeaturesARM;
2218
2219 //=== VK_VALVE_fragment_density_map_layered ===
2220 struct PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE;
2221 struct PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE;
2222 struct PipelineFragmentDensityMapLayeredCreateInfoVALVE;
2223
2224 //=== VK_KHR_robustness2 ===
2225 struct PhysicalDeviceRobustness2FeaturesKHR;
2226 using PhysicalDeviceRobustness2FeaturesEXT = PhysicalDeviceRobustness2FeaturesKHR;
2227 struct PhysicalDeviceRobustness2PropertiesKHR;
2228 using PhysicalDeviceRobustness2PropertiesEXT = PhysicalDeviceRobustness2PropertiesKHR;
2229
2230 #if defined( VK_ENABLE_BETA_EXTENSIONS )
2231 //=== VK_NV_present_metering ===
2232 struct SetPresentConfigNV;
2233 struct PhysicalDevicePresentMeteringFeaturesNV;
2234 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
2235
2236 //=== VK_EXT_fragment_density_map_offset ===
2237 struct PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT;
2238 using PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM = PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT;
2239 struct PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT;
2240 using PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM = PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT;
2241 struct RenderPassFragmentDensityMapOffsetEndInfoEXT;
2242 using SubpassFragmentDensityMapOffsetEndInfoQCOM = RenderPassFragmentDensityMapOffsetEndInfoEXT;
2243
2244 //=== VK_EXT_zero_initialize_device_memory ===
2245 struct PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT;
2246
2247 //=== VK_KHR_present_mode_fifo_latest_ready ===
2248 struct PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR;
2249 using PhysicalDevicePresentModeFifoLatestReadyFeaturesEXT = PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR;
2250
2251 //=== VK_EXT_shader_64bit_indexing ===
2252 struct PhysicalDeviceShader64BitIndexingFeaturesEXT;
2253
2254 //=== VK_EXT_custom_resolve ===
2255 struct PhysicalDeviceCustomResolveFeaturesEXT;
2256 struct BeginCustomResolveInfoEXT;
2257 struct CustomResolveCreateInfoEXT;
2258
2259 //=== VK_QCOM_data_graph_model ===
2260 struct PipelineCacheHeaderVersionDataGraphQCOM;
2261 struct DataGraphPipelineBuiltinModelCreateInfoQCOM;
2262 struct PhysicalDeviceDataGraphModelFeaturesQCOM;
2263
2264 //=== VK_KHR_maintenance10 ===
2265 struct PhysicalDeviceMaintenance10FeaturesKHR;
2266 struct PhysicalDeviceMaintenance10PropertiesKHR;
2267 struct RenderingEndInfoKHR;
2268 using RenderingEndInfoEXT = RenderingEndInfoKHR;
2269 struct RenderingAttachmentFlagsInfoKHR;
2270 struct ResolveImageModeInfoKHR;
2271
2272 //=== VK_SEC_pipeline_cache_incremental_mode ===
2273 struct PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC;
2274
2275 //=== VK_EXT_shader_uniform_buffer_unsized_array ===
2276 struct PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT;
2277
2278 //===================================
2279 //=== HANDLE forward declarations ===
2280 //===================================
2281
2282 //=== VK_VERSION_1_0 ===
2283 class Instance;
2284 class PhysicalDevice;
2285 class Device;
2286 class Queue;
2287 class DeviceMemory;
2288 class Fence;
2289 class Semaphore;
2290 class QueryPool;
2291 class Buffer;
2292 class Image;
2293 class ImageView;
2294 class CommandPool;
2295 class CommandBuffer;
2296 class Event;
2297 class BufferView;
2298 class ShaderModule;
2299 class PipelineCache;
2300 class Pipeline;
2301 class PipelineLayout;
2302 class Sampler;
2303 class DescriptorPool;
2304 class DescriptorSet;
2305 class DescriptorSetLayout;
2306 class Framebuffer;
2307 class RenderPass;
2308
2309 //=== VK_VERSION_1_1 ===
2310 class DescriptorUpdateTemplate;
2311 class SamplerYcbcrConversion;
2312
2313 //=== VK_VERSION_1_3 ===
2314 class PrivateDataSlot;
2315
2316 //=== VK_KHR_surface ===
2317 class SurfaceKHR;
2318
2319 //=== VK_KHR_swapchain ===
2320 class SwapchainKHR;
2321
2322 //=== VK_KHR_display ===
2323 class DisplayKHR;
2324 class DisplayModeKHR;
2325
2326 //=== VK_EXT_debug_report ===
2327 class DebugReportCallbackEXT;
2328
2329 //=== VK_KHR_video_queue ===
2330 class VideoSessionKHR;
2331 class VideoSessionParametersKHR;
2332
2333 //=== VK_NVX_binary_import ===
2334 class CuModuleNVX;
2335 class CuFunctionNVX;
2336
2337 //=== VK_EXT_debug_utils ===
2338 class DebugUtilsMessengerEXT;
2339
2340 //=== VK_KHR_acceleration_structure ===
2341 class AccelerationStructureKHR;
2342
2343 //=== VK_EXT_validation_cache ===
2344 class ValidationCacheEXT;
2345
2346 //=== VK_NV_ray_tracing ===
2347 class AccelerationStructureNV;
2348
2349 //=== VK_INTEL_performance_query ===
2350 class PerformanceConfigurationINTEL;
2351
2352 //=== VK_KHR_deferred_host_operations ===
2353 class DeferredOperationKHR;
2354
2355 //=== VK_NV_device_generated_commands ===
2356 class IndirectCommandsLayoutNV;
2357
2358 #if defined( VK_ENABLE_BETA_EXTENSIONS )
2359 //=== VK_NV_cuda_kernel_launch ===
2360 class CudaModuleNV;
2361 class CudaFunctionNV;
2362 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
2363
2364 #if defined( VK_USE_PLATFORM_FUCHSIA )
2365 //=== VK_FUCHSIA_buffer_collection ===
2366 class BufferCollectionFUCHSIA;
2367 #endif /*VK_USE_PLATFORM_FUCHSIA*/
2368
2369 //=== VK_EXT_opacity_micromap ===
2370 class MicromapEXT;
2371
2372 //=== VK_ARM_tensors ===
2373 class TensorARM;
2374 class TensorViewARM;
2375
2376 //=== VK_NV_optical_flow ===
2377 class OpticalFlowSessionNV;
2378
2379 //=== VK_EXT_shader_object ===
2380 class ShaderEXT;
2381
2382 //=== VK_KHR_pipeline_binary ===
2383 class PipelineBinaryKHR;
2384
2385 //=== VK_ARM_data_graph ===
2386 class DataGraphPipelineSessionARM;
2387
2388 //=== VK_NV_external_compute_queue ===
2389 class ExternalComputeQueueNV;
2390
2391 //=== VK_EXT_device_generated_commands ===
2392 class IndirectCommandsLayoutEXT;
2393 class IndirectExecutionSetEXT;
2394
2395 typedef void( VKAPI_PTR * PFN_VoidFunction )();
2396
2397 #ifndef VULKAN_HPP_NO_SMART_HANDLE
2398 //======================
2399 //=== UNIQUE HANDLEs ===
2400 //======================
2401
2402 //=== VK_VERSION_1_0 ===
2403 template <typename Dispatch>
2404 class UniqueHandleTraits<Instance, Dispatch>
2405 {
2406 public:
2407 using deleter = detail::ObjectDestroy<detail::NoParent, Dispatch>;
2408 };
2409
2410 using UniqueInstance = UniqueHandle<Instance, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2411
2412 template <typename Dispatch>
2413 class UniqueHandleTraits<Device, Dispatch>
2414 {
2415 public:
2416 using deleter = detail::ObjectDestroy<detail::NoParent, Dispatch>;
2417 };
2418
2419 using UniqueDevice = UniqueHandle<Device, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2420
2421 template <typename Dispatch>
2422 class UniqueHandleTraits<DeviceMemory, Dispatch>
2423 {
2424 public:
2425 using deleter = detail::ObjectFree<Device, Dispatch>;
2426 };
2427
2428 using UniqueDeviceMemory = UniqueHandle<DeviceMemory, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2429
2430 template <typename Dispatch>
2431 class UniqueHandleTraits<Fence, Dispatch>
2432 {
2433 public:
2434 using deleter = detail::ObjectDestroy<Device, Dispatch>;
2435 };
2436
2437 using UniqueFence = UniqueHandle<Fence, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2438
2439 template <typename Dispatch>
2440 class UniqueHandleTraits<Semaphore, Dispatch>
2441 {
2442 public:
2443 using deleter = detail::ObjectDestroy<Device, Dispatch>;
2444 };
2445
2446 using UniqueSemaphore = UniqueHandle<Semaphore, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2447
2448 template <typename Dispatch>
2449 class UniqueHandleTraits<QueryPool, Dispatch>
2450 {
2451 public:
2452 using deleter = detail::ObjectDestroy<Device, Dispatch>;
2453 };
2454
2455 using UniqueQueryPool = UniqueHandle<QueryPool, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2456
2457 template <typename Dispatch>
2458 class UniqueHandleTraits<Buffer, Dispatch>
2459 {
2460 public:
2461 using deleter = detail::ObjectDestroy<Device, Dispatch>;
2462 };
2463
2464 using UniqueBuffer = UniqueHandle<Buffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2465
2466 template <typename Dispatch>
2467 class UniqueHandleTraits<Image, Dispatch>
2468 {
2469 public:
2470 using deleter = detail::ObjectDestroy<Device, Dispatch>;
2471 };
2472
2473 using UniqueImage = UniqueHandle<Image, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2474
2475 template <typename Dispatch>
2476 class UniqueHandleTraits<ImageView, Dispatch>
2477 {
2478 public:
2479 using deleter = detail::ObjectDestroy<Device, Dispatch>;
2480 };
2481
2482 using UniqueImageView = UniqueHandle<ImageView, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2483
2484 template <typename Dispatch>
2485 class UniqueHandleTraits<CommandPool, Dispatch>
2486 {
2487 public:
2488 using deleter = detail::ObjectDestroy<Device, Dispatch>;
2489 };
2490
2491 using UniqueCommandPool = UniqueHandle<CommandPool, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2492
2493 template <typename Dispatch>
2494 class UniqueHandleTraits<CommandBuffer, Dispatch>
2495 {
2496 public:
2497 using deleter = detail::PoolFree<Device, CommandPool, Dispatch>;
2498 };
2499
2500 using UniqueCommandBuffer = UniqueHandle<CommandBuffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2501
2502 template <typename Dispatch>
2503 class UniqueHandleTraits<Event, Dispatch>
2504 {
2505 public:
2506 using deleter = detail::ObjectDestroy<Device, Dispatch>;
2507 };
2508
2509 using UniqueEvent = UniqueHandle<Event, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2510
2511 template <typename Dispatch>
2512 class UniqueHandleTraits<BufferView, Dispatch>
2513 {
2514 public:
2515 using deleter = detail::ObjectDestroy<Device, Dispatch>;
2516 };
2517
2518 using UniqueBufferView = UniqueHandle<BufferView, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2519
2520 template <typename Dispatch>
2521 class UniqueHandleTraits<ShaderModule, Dispatch>
2522 {
2523 public:
2524 using deleter = detail::ObjectDestroy<Device, Dispatch>;
2525 };
2526
2527 using UniqueShaderModule = UniqueHandle<ShaderModule, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2528
2529 template <typename Dispatch>
2530 class UniqueHandleTraits<PipelineCache, Dispatch>
2531 {
2532 public:
2533 using deleter = detail::ObjectDestroy<Device, Dispatch>;
2534 };
2535
2536 using UniquePipelineCache = UniqueHandle<PipelineCache, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2537
2538 template <typename Dispatch>
2539 class UniqueHandleTraits<Pipeline, Dispatch>
2540 {
2541 public:
2542 using deleter = detail::ObjectDestroy<Device, Dispatch>;
2543 };
2544
2545 using UniquePipeline = UniqueHandle<Pipeline, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2546
2547 template <typename Dispatch>
2548 class UniqueHandleTraits<PipelineLayout, Dispatch>
2549 {
2550 public:
2551 using deleter = detail::ObjectDestroy<Device, Dispatch>;
2552 };
2553
2554 using UniquePipelineLayout = UniqueHandle<PipelineLayout, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2555
2556 template <typename Dispatch>
2557 class UniqueHandleTraits<Sampler, Dispatch>
2558 {
2559 public:
2560 using deleter = detail::ObjectDestroy<Device, Dispatch>;
2561 };
2562
2563 using UniqueSampler = UniqueHandle<Sampler, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2564
2565 template <typename Dispatch>
2566 class UniqueHandleTraits<DescriptorPool, Dispatch>
2567 {
2568 public:
2569 using deleter = detail::ObjectDestroy<Device, Dispatch>;
2570 };
2571
2572 using UniqueDescriptorPool = UniqueHandle<DescriptorPool, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2573
2574 template <typename Dispatch>
2575 class UniqueHandleTraits<DescriptorSet, Dispatch>
2576 {
2577 public:
2578 using deleter = detail::PoolFree<Device, DescriptorPool, Dispatch>;
2579 };
2580
2581 using UniqueDescriptorSet = UniqueHandle<DescriptorSet, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2582
2583 template <typename Dispatch>
2584 class UniqueHandleTraits<DescriptorSetLayout, Dispatch>
2585 {
2586 public:
2587 using deleter = detail::ObjectDestroy<Device, Dispatch>;
2588 };
2589
2590 using UniqueDescriptorSetLayout = UniqueHandle<DescriptorSetLayout, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2591
2592 template <typename Dispatch>
2593 class UniqueHandleTraits<Framebuffer, Dispatch>
2594 {
2595 public:
2596 using deleter = detail::ObjectDestroy<Device, Dispatch>;
2597 };
2598
2599 using UniqueFramebuffer = UniqueHandle<Framebuffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2600
2601 template <typename Dispatch>
2602 class UniqueHandleTraits<RenderPass, Dispatch>
2603 {
2604 public:
2605 using deleter = detail::ObjectDestroy<Device, Dispatch>;
2606 };
2607
2608 using UniqueRenderPass = UniqueHandle<RenderPass, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2609
2610 //=== VK_VERSION_1_1 ===
2611 template <typename Dispatch>
2612 class UniqueHandleTraits<DescriptorUpdateTemplate, Dispatch>
2613 {
2614 public:
2615 using deleter = detail::ObjectDestroy<Device, Dispatch>;
2616 };
2617
2618 using UniqueDescriptorUpdateTemplate = UniqueHandle<DescriptorUpdateTemplate, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2619 using UniqueDescriptorUpdateTemplateKHR = UniqueHandle<DescriptorUpdateTemplate, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2620
2621 template <typename Dispatch>
2622 class UniqueHandleTraits<SamplerYcbcrConversion, Dispatch>
2623 {
2624 public:
2625 using deleter = detail::ObjectDestroy<Device, Dispatch>;
2626 };
2627
2628 using UniqueSamplerYcbcrConversion = UniqueHandle<SamplerYcbcrConversion, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2629 using UniqueSamplerYcbcrConversionKHR = UniqueHandle<SamplerYcbcrConversion, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2630
2631 //=== VK_VERSION_1_3 ===
2632 template <typename Dispatch>
2633 class UniqueHandleTraits<PrivateDataSlot, Dispatch>
2634 {
2635 public:
2636 using deleter = detail::ObjectDestroy<Device, Dispatch>;
2637 };
2638
2639 using UniquePrivateDataSlot = UniqueHandle<PrivateDataSlot, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2640 using UniquePrivateDataSlotEXT = UniqueHandle<PrivateDataSlot, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2641
2642 //=== VK_KHR_surface ===
2643 template <typename Dispatch>
2644 class UniqueHandleTraits<SurfaceKHR, Dispatch>
2645 {
2646 public:
2647 using deleter = detail::ObjectDestroy<Instance, Dispatch>;
2648 };
2649
2650 using UniqueSurfaceKHR = UniqueHandle<SurfaceKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2651
2652 //=== VK_KHR_swapchain ===
2653 template <typename Dispatch>
2654 class UniqueHandleTraits<SwapchainKHR, Dispatch>
2655 {
2656 public:
2657 using deleter = detail::ObjectDestroy<Device, Dispatch>;
2658 };
2659
2660 using UniqueSwapchainKHR = UniqueHandle<SwapchainKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2661
2662 //=== VK_KHR_display ===
2663 template <typename Dispatch>
2664 class UniqueHandleTraits<DisplayKHR, Dispatch>
2665 {
2666 public:
2667 using deleter = detail::ObjectDestroy<PhysicalDevice, Dispatch>;
2668 };
2669
2670 using UniqueDisplayKHR = UniqueHandle<DisplayKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2671
2672 //=== VK_EXT_debug_report ===
2673 template <typename Dispatch>
2674 class UniqueHandleTraits<DebugReportCallbackEXT, Dispatch>
2675 {
2676 public:
2677 using deleter = detail::ObjectDestroy<Instance, Dispatch>;
2678 };
2679
2680 using UniqueDebugReportCallbackEXT = UniqueHandle<DebugReportCallbackEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2681
2682 //=== VK_KHR_video_queue ===
2683 template <typename Dispatch>
2684 class UniqueHandleTraits<VideoSessionKHR, Dispatch>
2685 {
2686 public:
2687 using deleter = detail::ObjectDestroy<Device, Dispatch>;
2688 };
2689
2690 using UniqueVideoSessionKHR = UniqueHandle<VideoSessionKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2691
2692 template <typename Dispatch>
2693 class UniqueHandleTraits<VideoSessionParametersKHR, Dispatch>
2694 {
2695 public:
2696 using deleter = detail::ObjectDestroy<Device, Dispatch>;
2697 };
2698
2699 using UniqueVideoSessionParametersKHR = UniqueHandle<VideoSessionParametersKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2700
2701 //=== VK_NVX_binary_import ===
2702 template <typename Dispatch>
2703 class UniqueHandleTraits<CuModuleNVX, Dispatch>
2704 {
2705 public:
2706 using deleter = detail::ObjectDestroy<Device, Dispatch>;
2707 };
2708
2709 using UniqueCuModuleNVX = UniqueHandle<CuModuleNVX, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2710
2711 template <typename Dispatch>
2712 class UniqueHandleTraits<CuFunctionNVX, Dispatch>
2713 {
2714 public:
2715 using deleter = detail::ObjectDestroy<Device, Dispatch>;
2716 };
2717
2718 using UniqueCuFunctionNVX = UniqueHandle<CuFunctionNVX, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2719
2720 //=== VK_EXT_debug_utils ===
2721 template <typename Dispatch>
2722 class UniqueHandleTraits<DebugUtilsMessengerEXT, Dispatch>
2723 {
2724 public:
2725 using deleter = detail::ObjectDestroy<Instance, Dispatch>;
2726 };
2727
2728 using UniqueDebugUtilsMessengerEXT = UniqueHandle<DebugUtilsMessengerEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2729
2730 //=== VK_KHR_acceleration_structure ===
2731 template <typename Dispatch>
2732 class UniqueHandleTraits<AccelerationStructureKHR, Dispatch>
2733 {
2734 public:
2735 using deleter = detail::ObjectDestroy<Device, Dispatch>;
2736 };
2737
2738 using UniqueAccelerationStructureKHR = UniqueHandle<AccelerationStructureKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2739
2740 //=== VK_EXT_validation_cache ===
2741 template <typename Dispatch>
2742 class UniqueHandleTraits<ValidationCacheEXT, Dispatch>
2743 {
2744 public:
2745 using deleter = detail::ObjectDestroy<Device, Dispatch>;
2746 };
2747
2748 using UniqueValidationCacheEXT = UniqueHandle<ValidationCacheEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2749
2750 //=== VK_NV_ray_tracing ===
2751 template <typename Dispatch>
2752 class UniqueHandleTraits<AccelerationStructureNV, Dispatch>
2753 {
2754 public:
2755 using deleter = detail::ObjectDestroy<Device, Dispatch>;
2756 };
2757
2758 using UniqueAccelerationStructureNV = UniqueHandle<AccelerationStructureNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2759
2760 //=== VK_INTEL_performance_query ===
2761 template <typename Dispatch>
2762 class UniqueHandleTraits<PerformanceConfigurationINTEL, Dispatch>
2763 {
2764 public:
2765 using deleter = detail::ObjectDestroy<Device, Dispatch>;
2766 };
2767
2768 using UniquePerformanceConfigurationINTEL = UniqueHandle<PerformanceConfigurationINTEL, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2769
2770 //=== VK_KHR_deferred_host_operations ===
2771 template <typename Dispatch>
2772 class UniqueHandleTraits<DeferredOperationKHR, Dispatch>
2773 {
2774 public:
2775 using deleter = detail::ObjectDestroy<Device, Dispatch>;
2776 };
2777
2778 using UniqueDeferredOperationKHR = UniqueHandle<DeferredOperationKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2779
2780 //=== VK_NV_device_generated_commands ===
2781 template <typename Dispatch>
2782 class UniqueHandleTraits<IndirectCommandsLayoutNV, Dispatch>
2783 {
2784 public:
2785 using deleter = detail::ObjectDestroy<Device, Dispatch>;
2786 };
2787
2788 using UniqueIndirectCommandsLayoutNV = UniqueHandle<IndirectCommandsLayoutNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2789
2790 # if defined( VK_ENABLE_BETA_EXTENSIONS )
2791 //=== VK_NV_cuda_kernel_launch ===
2792 template <typename Dispatch>
2793 class UniqueHandleTraits<CudaModuleNV, Dispatch>
2794 {
2795 public:
2796 using deleter = detail::ObjectDestroy<Device, Dispatch>;
2797 };
2798
2799 using UniqueCudaModuleNV = UniqueHandle<CudaModuleNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2800
2801 template <typename Dispatch>
2802 class UniqueHandleTraits<CudaFunctionNV, Dispatch>
2803 {
2804 public:
2805 using deleter = detail::ObjectDestroy<Device, Dispatch>;
2806 };
2807
2808 using UniqueCudaFunctionNV = UniqueHandle<CudaFunctionNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2809 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
2810
2811 # if defined( VK_USE_PLATFORM_FUCHSIA )
2812 //=== VK_FUCHSIA_buffer_collection ===
2813 template <typename Dispatch>
2814 class UniqueHandleTraits<BufferCollectionFUCHSIA, Dispatch>
2815 {
2816 public:
2817 using deleter = detail::ObjectDestroy<Device, Dispatch>;
2818 };
2819
2820 using UniqueBufferCollectionFUCHSIA = UniqueHandle<BufferCollectionFUCHSIA, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2821 # endif /*VK_USE_PLATFORM_FUCHSIA*/
2822
2823 //=== VK_EXT_opacity_micromap ===
2824 template <typename Dispatch>
2825 class UniqueHandleTraits<MicromapEXT, Dispatch>
2826 {
2827 public:
2828 using deleter = detail::ObjectDestroy<Device, Dispatch>;
2829 };
2830
2831 using UniqueMicromapEXT = UniqueHandle<MicromapEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2832
2833 //=== VK_ARM_tensors ===
2834 template <typename Dispatch>
2835 class UniqueHandleTraits<TensorARM, Dispatch>
2836 {
2837 public:
2838 using deleter = detail::ObjectDestroy<Device, Dispatch>;
2839 };
2840
2841 using UniqueTensorARM = UniqueHandle<TensorARM, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2842
2843 template <typename Dispatch>
2844 class UniqueHandleTraits<TensorViewARM, Dispatch>
2845 {
2846 public:
2847 using deleter = detail::ObjectDestroy<Device, Dispatch>;
2848 };
2849
2850 using UniqueTensorViewARM = UniqueHandle<TensorViewARM, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2851
2852 //=== VK_NV_optical_flow ===
2853 template <typename Dispatch>
2854 class UniqueHandleTraits<OpticalFlowSessionNV, Dispatch>
2855 {
2856 public:
2857 using deleter = detail::ObjectDestroy<Device, Dispatch>;
2858 };
2859
2860 using UniqueOpticalFlowSessionNV = UniqueHandle<OpticalFlowSessionNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2861
2862 //=== VK_EXT_shader_object ===
2863 template <typename Dispatch>
2864 class UniqueHandleTraits<ShaderEXT, Dispatch>
2865 {
2866 public:
2867 using deleter = detail::ObjectDestroy<Device, Dispatch>;
2868 };
2869
2870 using UniqueShaderEXT = UniqueHandle<ShaderEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2871
2872 //=== VK_KHR_pipeline_binary ===
2873 template <typename Dispatch>
2874 class UniqueHandleTraits<PipelineBinaryKHR, Dispatch>
2875 {
2876 public:
2877 using deleter = detail::ObjectDestroy<Device, Dispatch>;
2878 };
2879
2880 using UniquePipelineBinaryKHR = UniqueHandle<PipelineBinaryKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2881
2882 //=== VK_ARM_data_graph ===
2883 template <typename Dispatch>
2884 class UniqueHandleTraits<DataGraphPipelineSessionARM, Dispatch>
2885 {
2886 public:
2887 using deleter = detail::ObjectDestroy<Device, Dispatch>;
2888 };
2889
2890 using UniqueDataGraphPipelineSessionARM = UniqueHandle<DataGraphPipelineSessionARM, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2891
2892 //=== VK_NV_external_compute_queue ===
2893 template <typename Dispatch>
2894 class UniqueHandleTraits<ExternalComputeQueueNV, Dispatch>
2895 {
2896 public:
2897 using deleter = detail::ObjectDestroy<Device, Dispatch>;
2898 };
2899
2900 using UniqueExternalComputeQueueNV = UniqueHandle<ExternalComputeQueueNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2901
2902 //=== VK_EXT_device_generated_commands ===
2903 template <typename Dispatch>
2904 class UniqueHandleTraits<IndirectCommandsLayoutEXT, Dispatch>
2905 {
2906 public:
2907 using deleter = detail::ObjectDestroy<Device, Dispatch>;
2908 };
2909
2910 using UniqueIndirectCommandsLayoutEXT = UniqueHandle<IndirectCommandsLayoutEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2911
2912 template <typename Dispatch>
2913 class UniqueHandleTraits<IndirectExecutionSetEXT, Dispatch>
2914 {
2915 public:
2916 using deleter = detail::ObjectDestroy<Device, Dispatch>;
2917 };
2918
2919 using UniqueIndirectExecutionSetEXT = UniqueHandle<IndirectExecutionSetEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2920 #endif /*VULKAN_HPP_NO_SMART_HANDLE*/
2921
2922 //===============
2923 //=== HANDLEs ===
2924 //===============
2925
2926 template <typename Type>
2927 struct isVulkanHandleType
2928 {
2929 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = false;
2930 };
2931
2932 // wrapper class for handle VkSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSurfaceKHR.html
2933 class SurfaceKHR
2934 {
2935 public:
2936 using CType = VkSurfaceKHR;
2937 using NativeType = VkSurfaceKHR;
2938
2939 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eSurfaceKHR;
2940 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eSurfaceKHR;
2941
2942 public:
2943 SurfaceKHR() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
2944
2945 SurfaceKHR( SurfaceKHR const & rhs ) = default;
2946 SurfaceKHR & operator=( SurfaceKHR const & rhs ) = default;
2947
2948 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
2949 SurfaceKHR( SurfaceKHR && rhs ) = default;
2950 SurfaceKHR & operator=( SurfaceKHR && rhs ) = default;
2951 #else
2952 SurfaceKHR( SurfaceKHR && rhs ) VULKAN_HPP_NOEXCEPT : m_surfaceKHR( exchange( rhs.m_surfaceKHR, {} ) ) {}
2953
2954 SurfaceKHR & operator=( SurfaceKHR && rhs ) VULKAN_HPP_NOEXCEPT
2955 {
2956 m_surfaceKHR = exchange( rhs.m_surfaceKHR, {} );
2957 return *this;
2958 }
2959 #endif
2960
2961 VULKAN_HPP_CONSTEXPR SurfaceKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
2962
2963 VULKAN_HPP_TYPESAFE_EXPLICIT SurfaceKHR( VkSurfaceKHR surfaceKHR ) VULKAN_HPP_NOEXCEPT : m_surfaceKHR( surfaceKHR ) {}
2964
2965 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
2966 SurfaceKHR & operator=( VkSurfaceKHR surfaceKHR ) VULKAN_HPP_NOEXCEPT
2967 {
2968 m_surfaceKHR = surfaceKHR;
2969 return *this;
2970 }
2971 #endif
2972
2973 SurfaceKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2974 {
2975 m_surfaceKHR = {};
2976 return *this;
2977 }
2978
2979 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSurfaceKHR() const VULKAN_HPP_NOEXCEPT
2980 {
2981 return m_surfaceKHR;
2982 }
2983
2984 explicit operator bool() const VULKAN_HPP_NOEXCEPT
2985 {
2986 return m_surfaceKHR != VK_NULL_HANDLE;
2987 }
2988
2989 bool operator!() const VULKAN_HPP_NOEXCEPT
2990 {
2991 return m_surfaceKHR == VK_NULL_HANDLE;
2992 }
2993
2994 private:
2995 VkSurfaceKHR m_surfaceKHR = {};
2996 };
2997
2998 template <>
2999 struct CppType<ObjectType, ObjectType::eSurfaceKHR>
3000 {
3001 using Type = SurfaceKHR;
3002 };
3003
3004 template <>
3005 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eSurfaceKHR>
3006 {
3007 using Type = SurfaceKHR;
3008 };
3009
3010 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
3011 template <>
3012 struct CppType<VkSurfaceKHR, VK_NULL_HANDLE>
3013 {
3014 using Type = SurfaceKHR;
3015 };
3016 #endif
3017
3018 template <>
3019 struct isVulkanHandleType<SurfaceKHR>
3020 {
3021 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3022 };
3023
3024 // wrapper class for handle VkDebugReportCallbackEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugReportCallbackEXT.html
3025 class DebugReportCallbackEXT
3026 {
3027 public:
3028 using CType = VkDebugReportCallbackEXT;
3029 using NativeType = VkDebugReportCallbackEXT;
3030
3031 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDebugReportCallbackEXT;
3032 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eDebugReportCallbackEXT;
3033
3034 public:
3035 DebugReportCallbackEXT() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
3036
3037 DebugReportCallbackEXT( DebugReportCallbackEXT const & rhs ) = default;
3038 DebugReportCallbackEXT & operator=( DebugReportCallbackEXT const & rhs ) = default;
3039
3040 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
3041 DebugReportCallbackEXT( DebugReportCallbackEXT && rhs ) = default;
3042 DebugReportCallbackEXT & operator=( DebugReportCallbackEXT && rhs ) = default;
3043 #else
3044 DebugReportCallbackEXT( DebugReportCallbackEXT && rhs ) VULKAN_HPP_NOEXCEPT : m_debugReportCallbackEXT( exchange( rhs.m_debugReportCallbackEXT, {} ) ) {}
3045
3046 DebugReportCallbackEXT & operator=( DebugReportCallbackEXT && rhs ) VULKAN_HPP_NOEXCEPT
3047 {
3048 m_debugReportCallbackEXT = exchange( rhs.m_debugReportCallbackEXT, {} );
3049 return *this;
3050 }
3051 #endif
3052
3053 VULKAN_HPP_CONSTEXPR DebugReportCallbackEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
3054
3055 VULKAN_HPP_TYPESAFE_EXPLICIT DebugReportCallbackEXT( VkDebugReportCallbackEXT debugReportCallbackEXT ) VULKAN_HPP_NOEXCEPT
3056 : m_debugReportCallbackEXT( debugReportCallbackEXT )
3057 {
3058 }
3059
3060 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
3061 DebugReportCallbackEXT & operator=( VkDebugReportCallbackEXT debugReportCallbackEXT ) VULKAN_HPP_NOEXCEPT
3062 {
3063 m_debugReportCallbackEXT = debugReportCallbackEXT;
3064 return *this;
3065 }
3066 #endif
3067
3068 DebugReportCallbackEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3069 {
3070 m_debugReportCallbackEXT = {};
3071 return *this;
3072 }
3073
3074 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDebugReportCallbackEXT() const VULKAN_HPP_NOEXCEPT
3075 {
3076 return m_debugReportCallbackEXT;
3077 }
3078
3079 explicit operator bool() const VULKAN_HPP_NOEXCEPT
3080 {
3081 return m_debugReportCallbackEXT != VK_NULL_HANDLE;
3082 }
3083
3084 bool operator!() const VULKAN_HPP_NOEXCEPT
3085 {
3086 return m_debugReportCallbackEXT == VK_NULL_HANDLE;
3087 }
3088
3089 private:
3090 VkDebugReportCallbackEXT m_debugReportCallbackEXT = {};
3091 };
3092
3093 template <>
3094 struct CppType<ObjectType, ObjectType::eDebugReportCallbackEXT>
3095 {
3096 using Type = DebugReportCallbackEXT;
3097 };
3098
3099 template <>
3100 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eDebugReportCallbackEXT>
3101 {
3102 using Type = DebugReportCallbackEXT;
3103 };
3104
3105 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
3106 template <>
3107 struct CppType<VkDebugReportCallbackEXT, VK_NULL_HANDLE>
3108 {
3109 using Type = DebugReportCallbackEXT;
3110 };
3111 #endif
3112
3113 template <>
3114 struct isVulkanHandleType<DebugReportCallbackEXT>
3115 {
3116 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3117 };
3118
3119 // wrapper class for handle VkDebugUtilsMessengerEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugUtilsMessengerEXT.html
3120 class DebugUtilsMessengerEXT
3121 {
3122 public:
3123 using CType = VkDebugUtilsMessengerEXT;
3124 using NativeType = VkDebugUtilsMessengerEXT;
3125
3126 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDebugUtilsMessengerEXT;
3127 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown;
3128
3129 public:
3130 DebugUtilsMessengerEXT() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
3131
3132 DebugUtilsMessengerEXT( DebugUtilsMessengerEXT const & rhs ) = default;
3133 DebugUtilsMessengerEXT & operator=( DebugUtilsMessengerEXT const & rhs ) = default;
3134
3135 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
3136 DebugUtilsMessengerEXT( DebugUtilsMessengerEXT && rhs ) = default;
3137 DebugUtilsMessengerEXT & operator=( DebugUtilsMessengerEXT && rhs ) = default;
3138 #else
3139 DebugUtilsMessengerEXT( DebugUtilsMessengerEXT && rhs ) VULKAN_HPP_NOEXCEPT : m_debugUtilsMessengerEXT( exchange( rhs.m_debugUtilsMessengerEXT, {} ) ) {}
3140
3141 DebugUtilsMessengerEXT & operator=( DebugUtilsMessengerEXT && rhs ) VULKAN_HPP_NOEXCEPT
3142 {
3143 m_debugUtilsMessengerEXT = exchange( rhs.m_debugUtilsMessengerEXT, {} );
3144 return *this;
3145 }
3146 #endif
3147
3148 VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
3149
3150 VULKAN_HPP_TYPESAFE_EXPLICIT DebugUtilsMessengerEXT( VkDebugUtilsMessengerEXT debugUtilsMessengerEXT ) VULKAN_HPP_NOEXCEPT
3151 : m_debugUtilsMessengerEXT( debugUtilsMessengerEXT )
3152 {
3153 }
3154
3155 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
3156 DebugUtilsMessengerEXT & operator=( VkDebugUtilsMessengerEXT debugUtilsMessengerEXT ) VULKAN_HPP_NOEXCEPT
3157 {
3158 m_debugUtilsMessengerEXT = debugUtilsMessengerEXT;
3159 return *this;
3160 }
3161 #endif
3162
3163 DebugUtilsMessengerEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3164 {
3165 m_debugUtilsMessengerEXT = {};
3166 return *this;
3167 }
3168
3169 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDebugUtilsMessengerEXT() const VULKAN_HPP_NOEXCEPT
3170 {
3171 return m_debugUtilsMessengerEXT;
3172 }
3173
3174 explicit operator bool() const VULKAN_HPP_NOEXCEPT
3175 {
3176 return m_debugUtilsMessengerEXT != VK_NULL_HANDLE;
3177 }
3178
3179 bool operator!() const VULKAN_HPP_NOEXCEPT
3180 {
3181 return m_debugUtilsMessengerEXT == VK_NULL_HANDLE;
3182 }
3183
3184 private:
3185 VkDebugUtilsMessengerEXT m_debugUtilsMessengerEXT = {};
3186 };
3187
3188 template <>
3189 struct CppType<ObjectType, ObjectType::eDebugUtilsMessengerEXT>
3190 {
3191 using Type = DebugUtilsMessengerEXT;
3192 };
3193
3194 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
3195 template <>
3196 struct CppType<VkDebugUtilsMessengerEXT, VK_NULL_HANDLE>
3197 {
3198 using Type = DebugUtilsMessengerEXT;
3199 };
3200 #endif
3201
3202 template <>
3203 struct isVulkanHandleType<DebugUtilsMessengerEXT>
3204 {
3205 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3206 };
3207
3208 // wrapper class for handle VkDisplayKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplayKHR.html
3209 class DisplayKHR
3210 {
3211 public:
3212 using CType = VkDisplayKHR;
3213 using NativeType = VkDisplayKHR;
3214
3215 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDisplayKHR;
3216 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eDisplayKHR;
3217
3218 public:
3219 DisplayKHR() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
3220
3221 DisplayKHR( DisplayKHR const & rhs ) = default;
3222 DisplayKHR & operator=( DisplayKHR const & rhs ) = default;
3223
3224 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
3225 DisplayKHR( DisplayKHR && rhs ) = default;
3226 DisplayKHR & operator=( DisplayKHR && rhs ) = default;
3227 #else
3228 DisplayKHR( DisplayKHR && rhs ) VULKAN_HPP_NOEXCEPT : m_displayKHR( exchange( rhs.m_displayKHR, {} ) ) {}
3229
3230 DisplayKHR & operator=( DisplayKHR && rhs ) VULKAN_HPP_NOEXCEPT
3231 {
3232 m_displayKHR = exchange( rhs.m_displayKHR, {} );
3233 return *this;
3234 }
3235 #endif
3236
3237 VULKAN_HPP_CONSTEXPR DisplayKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
3238
3239 VULKAN_HPP_TYPESAFE_EXPLICIT DisplayKHR( VkDisplayKHR displayKHR ) VULKAN_HPP_NOEXCEPT : m_displayKHR( displayKHR ) {}
3240
3241 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
3242 DisplayKHR & operator=( VkDisplayKHR displayKHR ) VULKAN_HPP_NOEXCEPT
3243 {
3244 m_displayKHR = displayKHR;
3245 return *this;
3246 }
3247 #endif
3248
3249 DisplayKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3250 {
3251 m_displayKHR = {};
3252 return *this;
3253 }
3254
3255 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDisplayKHR() const VULKAN_HPP_NOEXCEPT
3256 {
3257 return m_displayKHR;
3258 }
3259
3260 explicit operator bool() const VULKAN_HPP_NOEXCEPT
3261 {
3262 return m_displayKHR != VK_NULL_HANDLE;
3263 }
3264
3265 bool operator!() const VULKAN_HPP_NOEXCEPT
3266 {
3267 return m_displayKHR == VK_NULL_HANDLE;
3268 }
3269
3270 private:
3271 VkDisplayKHR m_displayKHR = {};
3272 };
3273
3274 template <>
3275 struct CppType<ObjectType, ObjectType::eDisplayKHR>
3276 {
3277 using Type = DisplayKHR;
3278 };
3279
3280 template <>
3281 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eDisplayKHR>
3282 {
3283 using Type = DisplayKHR;
3284 };
3285
3286 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
3287 template <>
3288 struct CppType<VkDisplayKHR, VK_NULL_HANDLE>
3289 {
3290 using Type = DisplayKHR;
3291 };
3292 #endif
3293
3294 template <>
3295 struct isVulkanHandleType<DisplayKHR>
3296 {
3297 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3298 };
3299
3300 // wrapper class for handle VkSwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSwapchainKHR.html
3301 class SwapchainKHR
3302 {
3303 public:
3304 using CType = VkSwapchainKHR;
3305 using NativeType = VkSwapchainKHR;
3306
3307 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eSwapchainKHR;
3308 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eSwapchainKHR;
3309
3310 public:
3311 SwapchainKHR() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
3312
3313 SwapchainKHR( SwapchainKHR const & rhs ) = default;
3314 SwapchainKHR & operator=( SwapchainKHR const & rhs ) = default;
3315
3316 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
3317 SwapchainKHR( SwapchainKHR && rhs ) = default;
3318 SwapchainKHR & operator=( SwapchainKHR && rhs ) = default;
3319 #else
3320 SwapchainKHR( SwapchainKHR && rhs ) VULKAN_HPP_NOEXCEPT : m_swapchainKHR( exchange( rhs.m_swapchainKHR, {} ) ) {}
3321
3322 SwapchainKHR & operator=( SwapchainKHR && rhs ) VULKAN_HPP_NOEXCEPT
3323 {
3324 m_swapchainKHR = exchange( rhs.m_swapchainKHR, {} );
3325 return *this;
3326 }
3327 #endif
3328
3329 VULKAN_HPP_CONSTEXPR SwapchainKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
3330
3331 VULKAN_HPP_TYPESAFE_EXPLICIT SwapchainKHR( VkSwapchainKHR swapchainKHR ) VULKAN_HPP_NOEXCEPT : m_swapchainKHR( swapchainKHR ) {}
3332
3333 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
3334 SwapchainKHR & operator=( VkSwapchainKHR swapchainKHR ) VULKAN_HPP_NOEXCEPT
3335 {
3336 m_swapchainKHR = swapchainKHR;
3337 return *this;
3338 }
3339 #endif
3340
3341 SwapchainKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3342 {
3343 m_swapchainKHR = {};
3344 return *this;
3345 }
3346
3347 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSwapchainKHR() const VULKAN_HPP_NOEXCEPT
3348 {
3349 return m_swapchainKHR;
3350 }
3351
3352 explicit operator bool() const VULKAN_HPP_NOEXCEPT
3353 {
3354 return m_swapchainKHR != VK_NULL_HANDLE;
3355 }
3356
3357 bool operator!() const VULKAN_HPP_NOEXCEPT
3358 {
3359 return m_swapchainKHR == VK_NULL_HANDLE;
3360 }
3361
3362 private:
3363 VkSwapchainKHR m_swapchainKHR = {};
3364 };
3365
3366 template <>
3367 struct CppType<ObjectType, ObjectType::eSwapchainKHR>
3368 {
3369 using Type = SwapchainKHR;
3370 };
3371
3372 template <>
3373 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eSwapchainKHR>
3374 {
3375 using Type = SwapchainKHR;
3376 };
3377
3378 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
3379 template <>
3380 struct CppType<VkSwapchainKHR, VK_NULL_HANDLE>
3381 {
3382 using Type = SwapchainKHR;
3383 };
3384 #endif
3385
3386 template <>
3387 struct isVulkanHandleType<SwapchainKHR>
3388 {
3389 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3390 };
3391
3392 // wrapper class for handle VkImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImage.html
3393 class Image
3394 {
3395 public:
3396 using CType = VkImage;
3397 using NativeType = VkImage;
3398
3399 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eImage;
3400 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eImage;
3401
3402 public:
3403 Image() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
3404
3405 Image( Image const & rhs ) = default;
3406 Image & operator=( Image const & rhs ) = default;
3407
3408 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
3409 Image( Image && rhs ) = default;
3410 Image & operator=( Image && rhs ) = default;
3411 #else
3412 Image( Image && rhs ) VULKAN_HPP_NOEXCEPT : m_image( exchange( rhs.m_image, {} ) ) {}
3413
3414 Image & operator=( Image && rhs ) VULKAN_HPP_NOEXCEPT
3415 {
3416 m_image = exchange( rhs.m_image, {} );
3417 return *this;
3418 }
3419 #endif
3420
3421 VULKAN_HPP_CONSTEXPR Image( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
3422
3423 VULKAN_HPP_TYPESAFE_EXPLICIT Image( VkImage image ) VULKAN_HPP_NOEXCEPT : m_image( image ) {}
3424
3425 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
3426 Image & operator=( VkImage image ) VULKAN_HPP_NOEXCEPT
3427 {
3428 m_image = image;
3429 return *this;
3430 }
3431 #endif
3432
3433 Image & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3434 {
3435 m_image = {};
3436 return *this;
3437 }
3438
3439 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkImage() const VULKAN_HPP_NOEXCEPT
3440 {
3441 return m_image;
3442 }
3443
3444 explicit operator bool() const VULKAN_HPP_NOEXCEPT
3445 {
3446 return m_image != VK_NULL_HANDLE;
3447 }
3448
3449 bool operator!() const VULKAN_HPP_NOEXCEPT
3450 {
3451 return m_image == VK_NULL_HANDLE;
3452 }
3453
3454 private:
3455 VkImage m_image = {};
3456 };
3457
3458 template <>
3459 struct CppType<ObjectType, ObjectType::eImage>
3460 {
3461 using Type = Image;
3462 };
3463
3464 template <>
3465 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eImage>
3466 {
3467 using Type = Image;
3468 };
3469
3470 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
3471 template <>
3472 struct CppType<VkImage, VK_NULL_HANDLE>
3473 {
3474 using Type = Image;
3475 };
3476 #endif
3477
3478 template <>
3479 struct isVulkanHandleType<Image>
3480 {
3481 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3482 };
3483
3484 // wrapper class for handle VkSemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSemaphore.html
3485 class Semaphore
3486 {
3487 public:
3488 using CType = VkSemaphore;
3489 using NativeType = VkSemaphore;
3490
3491 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eSemaphore;
3492 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eSemaphore;
3493
3494 public:
3495 Semaphore() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
3496
3497 Semaphore( Semaphore const & rhs ) = default;
3498 Semaphore & operator=( Semaphore const & rhs ) = default;
3499
3500 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
3501 Semaphore( Semaphore && rhs ) = default;
3502 Semaphore & operator=( Semaphore && rhs ) = default;
3503 #else
3504 Semaphore( Semaphore && rhs ) VULKAN_HPP_NOEXCEPT : m_semaphore( exchange( rhs.m_semaphore, {} ) ) {}
3505
3506 Semaphore & operator=( Semaphore && rhs ) VULKAN_HPP_NOEXCEPT
3507 {
3508 m_semaphore = exchange( rhs.m_semaphore, {} );
3509 return *this;
3510 }
3511 #endif
3512
3513 VULKAN_HPP_CONSTEXPR Semaphore( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
3514
3515 VULKAN_HPP_TYPESAFE_EXPLICIT Semaphore( VkSemaphore semaphore ) VULKAN_HPP_NOEXCEPT : m_semaphore( semaphore ) {}
3516
3517 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
3518 Semaphore & operator=( VkSemaphore semaphore ) VULKAN_HPP_NOEXCEPT
3519 {
3520 m_semaphore = semaphore;
3521 return *this;
3522 }
3523 #endif
3524
3525 Semaphore & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3526 {
3527 m_semaphore = {};
3528 return *this;
3529 }
3530
3531 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSemaphore() const VULKAN_HPP_NOEXCEPT
3532 {
3533 return m_semaphore;
3534 }
3535
3536 explicit operator bool() const VULKAN_HPP_NOEXCEPT
3537 {
3538 return m_semaphore != VK_NULL_HANDLE;
3539 }
3540
3541 bool operator!() const VULKAN_HPP_NOEXCEPT
3542 {
3543 return m_semaphore == VK_NULL_HANDLE;
3544 }
3545
3546 private:
3547 VkSemaphore m_semaphore = {};
3548 };
3549
3550 template <>
3551 struct CppType<ObjectType, ObjectType::eSemaphore>
3552 {
3553 using Type = Semaphore;
3554 };
3555
3556 template <>
3557 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eSemaphore>
3558 {
3559 using Type = Semaphore;
3560 };
3561
3562 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
3563 template <>
3564 struct CppType<VkSemaphore, VK_NULL_HANDLE>
3565 {
3566 using Type = Semaphore;
3567 };
3568 #endif
3569
3570 template <>
3571 struct isVulkanHandleType<Semaphore>
3572 {
3573 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3574 };
3575
3576 // wrapper class for handle VkFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFence.html
3577 class Fence
3578 {
3579 public:
3580 using CType = VkFence;
3581 using NativeType = VkFence;
3582
3583 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eFence;
3584 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eFence;
3585
3586 public:
3587 Fence() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
3588
3589 Fence( Fence const & rhs ) = default;
3590 Fence & operator=( Fence const & rhs ) = default;
3591
3592 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
3593 Fence( Fence && rhs ) = default;
3594 Fence & operator=( Fence && rhs ) = default;
3595 #else
3596 Fence( Fence && rhs ) VULKAN_HPP_NOEXCEPT : m_fence( exchange( rhs.m_fence, {} ) ) {}
3597
3598 Fence & operator=( Fence && rhs ) VULKAN_HPP_NOEXCEPT
3599 {
3600 m_fence = exchange( rhs.m_fence, {} );
3601 return *this;
3602 }
3603 #endif
3604
3605 VULKAN_HPP_CONSTEXPR Fence( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
3606
3607 VULKAN_HPP_TYPESAFE_EXPLICIT Fence( VkFence fence ) VULKAN_HPP_NOEXCEPT : m_fence( fence ) {}
3608
3609 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
3610 Fence & operator=( VkFence fence ) VULKAN_HPP_NOEXCEPT
3611 {
3612 m_fence = fence;
3613 return *this;
3614 }
3615 #endif
3616
3617 Fence & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3618 {
3619 m_fence = {};
3620 return *this;
3621 }
3622
3623 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkFence() const VULKAN_HPP_NOEXCEPT
3624 {
3625 return m_fence;
3626 }
3627
3628 explicit operator bool() const VULKAN_HPP_NOEXCEPT
3629 {
3630 return m_fence != VK_NULL_HANDLE;
3631 }
3632
3633 bool operator!() const VULKAN_HPP_NOEXCEPT
3634 {
3635 return m_fence == VK_NULL_HANDLE;
3636 }
3637
3638 private:
3639 VkFence m_fence = {};
3640 };
3641
3642 template <>
3643 struct CppType<ObjectType, ObjectType::eFence>
3644 {
3645 using Type = Fence;
3646 };
3647
3648 template <>
3649 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eFence>
3650 {
3651 using Type = Fence;
3652 };
3653
3654 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
3655 template <>
3656 struct CppType<VkFence, VK_NULL_HANDLE>
3657 {
3658 using Type = Fence;
3659 };
3660 #endif
3661
3662 template <>
3663 struct isVulkanHandleType<Fence>
3664 {
3665 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3666 };
3667
3668 // wrapper class for handle VkPerformanceConfigurationINTEL, see
3669 // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerformanceConfigurationINTEL.html
3670 class PerformanceConfigurationINTEL
3671 {
3672 public:
3673 using CType = VkPerformanceConfigurationINTEL;
3674 using NativeType = VkPerformanceConfigurationINTEL;
3675
3676 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePerformanceConfigurationINTEL;
3677 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown;
3678
3679 public:
3680 PerformanceConfigurationINTEL() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
3681
3682 PerformanceConfigurationINTEL( PerformanceConfigurationINTEL const & rhs ) = default;
3683 PerformanceConfigurationINTEL & operator=( PerformanceConfigurationINTEL const & rhs ) = default;
3684
3685 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
3686 PerformanceConfigurationINTEL( PerformanceConfigurationINTEL && rhs ) = default;
3687 PerformanceConfigurationINTEL & operator=( PerformanceConfigurationINTEL && rhs ) = default;
3688 #else
3689 PerformanceConfigurationINTEL( PerformanceConfigurationINTEL && rhs ) VULKAN_HPP_NOEXCEPT
3690 : m_performanceConfigurationINTEL( exchange( rhs.m_performanceConfigurationINTEL, {} ) )
3691 {
3692 }
3693
3694 PerformanceConfigurationINTEL & operator=( PerformanceConfigurationINTEL && rhs ) VULKAN_HPP_NOEXCEPT
3695 {
3696 m_performanceConfigurationINTEL = exchange( rhs.m_performanceConfigurationINTEL, {} );
3697 return *this;
3698 }
3699 #endif
3700
3701 VULKAN_HPP_CONSTEXPR PerformanceConfigurationINTEL( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
3702
3703 VULKAN_HPP_TYPESAFE_EXPLICIT PerformanceConfigurationINTEL( VkPerformanceConfigurationINTEL performanceConfigurationINTEL ) VULKAN_HPP_NOEXCEPT
3704 : m_performanceConfigurationINTEL( performanceConfigurationINTEL )
3705 {
3706 }
3707
3708 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
3709 PerformanceConfigurationINTEL & operator=( VkPerformanceConfigurationINTEL performanceConfigurationINTEL ) VULKAN_HPP_NOEXCEPT
3710 {
3711 m_performanceConfigurationINTEL = performanceConfigurationINTEL;
3712 return *this;
3713 }
3714 #endif
3715
3716 PerformanceConfigurationINTEL & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3717 {
3718 m_performanceConfigurationINTEL = {};
3719 return *this;
3720 }
3721
3722 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPerformanceConfigurationINTEL() const VULKAN_HPP_NOEXCEPT
3723 {
3724 return m_performanceConfigurationINTEL;
3725 }
3726
3727 explicit operator bool() const VULKAN_HPP_NOEXCEPT
3728 {
3729 return m_performanceConfigurationINTEL != VK_NULL_HANDLE;
3730 }
3731
3732 bool operator!() const VULKAN_HPP_NOEXCEPT
3733 {
3734 return m_performanceConfigurationINTEL == VK_NULL_HANDLE;
3735 }
3736
3737 private:
3738 VkPerformanceConfigurationINTEL m_performanceConfigurationINTEL = {};
3739 };
3740
3741 template <>
3742 struct CppType<ObjectType, ObjectType::ePerformanceConfigurationINTEL>
3743 {
3744 using Type = PerformanceConfigurationINTEL;
3745 };
3746
3747 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
3748 template <>
3749 struct CppType<VkPerformanceConfigurationINTEL, VK_NULL_HANDLE>
3750 {
3751 using Type = PerformanceConfigurationINTEL;
3752 };
3753 #endif
3754
3755 template <>
3756 struct isVulkanHandleType<PerformanceConfigurationINTEL>
3757 {
3758 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3759 };
3760
3761 // wrapper class for handle VkQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueryPool.html
3762 class QueryPool
3763 {
3764 public:
3765 using CType = VkQueryPool;
3766 using NativeType = VkQueryPool;
3767
3768 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eQueryPool;
3769 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eQueryPool;
3770
3771 public:
3772 QueryPool() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
3773
3774 QueryPool( QueryPool const & rhs ) = default;
3775 QueryPool & operator=( QueryPool const & rhs ) = default;
3776
3777 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
3778 QueryPool( QueryPool && rhs ) = default;
3779 QueryPool & operator=( QueryPool && rhs ) = default;
3780 #else
3781 QueryPool( QueryPool && rhs ) VULKAN_HPP_NOEXCEPT : m_queryPool( exchange( rhs.m_queryPool, {} ) ) {}
3782
3783 QueryPool & operator=( QueryPool && rhs ) VULKAN_HPP_NOEXCEPT
3784 {
3785 m_queryPool = exchange( rhs.m_queryPool, {} );
3786 return *this;
3787 }
3788 #endif
3789
3790 VULKAN_HPP_CONSTEXPR QueryPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
3791
3792 VULKAN_HPP_TYPESAFE_EXPLICIT QueryPool( VkQueryPool queryPool ) VULKAN_HPP_NOEXCEPT : m_queryPool( queryPool ) {}
3793
3794 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
3795 QueryPool & operator=( VkQueryPool queryPool ) VULKAN_HPP_NOEXCEPT
3796 {
3797 m_queryPool = queryPool;
3798 return *this;
3799 }
3800 #endif
3801
3802 QueryPool & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3803 {
3804 m_queryPool = {};
3805 return *this;
3806 }
3807
3808 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkQueryPool() const VULKAN_HPP_NOEXCEPT
3809 {
3810 return m_queryPool;
3811 }
3812
3813 explicit operator bool() const VULKAN_HPP_NOEXCEPT
3814 {
3815 return m_queryPool != VK_NULL_HANDLE;
3816 }
3817
3818 bool operator!() const VULKAN_HPP_NOEXCEPT
3819 {
3820 return m_queryPool == VK_NULL_HANDLE;
3821 }
3822
3823 private:
3824 VkQueryPool m_queryPool = {};
3825 };
3826
3827 template <>
3828 struct CppType<ObjectType, ObjectType::eQueryPool>
3829 {
3830 using Type = QueryPool;
3831 };
3832
3833 template <>
3834 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eQueryPool>
3835 {
3836 using Type = QueryPool;
3837 };
3838
3839 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
3840 template <>
3841 struct CppType<VkQueryPool, VK_NULL_HANDLE>
3842 {
3843 using Type = QueryPool;
3844 };
3845 #endif
3846
3847 template <>
3848 struct isVulkanHandleType<QueryPool>
3849 {
3850 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3851 };
3852
3853 // wrapper class for handle VkBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBuffer.html
3854 class Buffer
3855 {
3856 public:
3857 using CType = VkBuffer;
3858 using NativeType = VkBuffer;
3859
3860 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eBuffer;
3861 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eBuffer;
3862
3863 public:
3864 Buffer() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
3865
3866 Buffer( Buffer const & rhs ) = default;
3867 Buffer & operator=( Buffer const & rhs ) = default;
3868
3869 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
3870 Buffer( Buffer && rhs ) = default;
3871 Buffer & operator=( Buffer && rhs ) = default;
3872 #else
3873 Buffer( Buffer && rhs ) VULKAN_HPP_NOEXCEPT : m_buffer( exchange( rhs.m_buffer, {} ) ) {}
3874
3875 Buffer & operator=( Buffer && rhs ) VULKAN_HPP_NOEXCEPT
3876 {
3877 m_buffer = exchange( rhs.m_buffer, {} );
3878 return *this;
3879 }
3880 #endif
3881
3882 VULKAN_HPP_CONSTEXPR Buffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
3883
3884 VULKAN_HPP_TYPESAFE_EXPLICIT Buffer( VkBuffer buffer ) VULKAN_HPP_NOEXCEPT : m_buffer( buffer ) {}
3885
3886 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
3887 Buffer & operator=( VkBuffer buffer ) VULKAN_HPP_NOEXCEPT
3888 {
3889 m_buffer = buffer;
3890 return *this;
3891 }
3892 #endif
3893
3894 Buffer & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3895 {
3896 m_buffer = {};
3897 return *this;
3898 }
3899
3900 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBuffer() const VULKAN_HPP_NOEXCEPT
3901 {
3902 return m_buffer;
3903 }
3904
3905 explicit operator bool() const VULKAN_HPP_NOEXCEPT
3906 {
3907 return m_buffer != VK_NULL_HANDLE;
3908 }
3909
3910 bool operator!() const VULKAN_HPP_NOEXCEPT
3911 {
3912 return m_buffer == VK_NULL_HANDLE;
3913 }
3914
3915 private:
3916 VkBuffer m_buffer = {};
3917 };
3918
3919 template <>
3920 struct CppType<ObjectType, ObjectType::eBuffer>
3921 {
3922 using Type = Buffer;
3923 };
3924
3925 template <>
3926 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eBuffer>
3927 {
3928 using Type = Buffer;
3929 };
3930
3931 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
3932 template <>
3933 struct CppType<VkBuffer, VK_NULL_HANDLE>
3934 {
3935 using Type = Buffer;
3936 };
3937 #endif
3938
3939 template <>
3940 struct isVulkanHandleType<Buffer>
3941 {
3942 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3943 };
3944
3945 // wrapper class for handle VkPipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineLayout.html
3946 class PipelineLayout
3947 {
3948 public:
3949 using CType = VkPipelineLayout;
3950 using NativeType = VkPipelineLayout;
3951
3952 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePipelineLayout;
3953 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::ePipelineLayout;
3954
3955 public:
3956 PipelineLayout() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
3957
3958 PipelineLayout( PipelineLayout const & rhs ) = default;
3959 PipelineLayout & operator=( PipelineLayout const & rhs ) = default;
3960
3961 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
3962 PipelineLayout( PipelineLayout && rhs ) = default;
3963 PipelineLayout & operator=( PipelineLayout && rhs ) = default;
3964 #else
3965 PipelineLayout( PipelineLayout && rhs ) VULKAN_HPP_NOEXCEPT : m_pipelineLayout( exchange( rhs.m_pipelineLayout, {} ) ) {}
3966
3967 PipelineLayout & operator=( PipelineLayout && rhs ) VULKAN_HPP_NOEXCEPT
3968 {
3969 m_pipelineLayout = exchange( rhs.m_pipelineLayout, {} );
3970 return *this;
3971 }
3972 #endif
3973
3974 VULKAN_HPP_CONSTEXPR PipelineLayout( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
3975
3976 VULKAN_HPP_TYPESAFE_EXPLICIT PipelineLayout( VkPipelineLayout pipelineLayout ) VULKAN_HPP_NOEXCEPT : m_pipelineLayout( pipelineLayout ) {}
3977
3978 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
3979 PipelineLayout & operator=( VkPipelineLayout pipelineLayout ) VULKAN_HPP_NOEXCEPT
3980 {
3981 m_pipelineLayout = pipelineLayout;
3982 return *this;
3983 }
3984 #endif
3985
3986 PipelineLayout & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3987 {
3988 m_pipelineLayout = {};
3989 return *this;
3990 }
3991
3992 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineLayout() const VULKAN_HPP_NOEXCEPT
3993 {
3994 return m_pipelineLayout;
3995 }
3996
3997 explicit operator bool() const VULKAN_HPP_NOEXCEPT
3998 {
3999 return m_pipelineLayout != VK_NULL_HANDLE;
4000 }
4001
4002 bool operator!() const VULKAN_HPP_NOEXCEPT
4003 {
4004 return m_pipelineLayout == VK_NULL_HANDLE;
4005 }
4006
4007 private:
4008 VkPipelineLayout m_pipelineLayout = {};
4009 };
4010
4011 template <>
4012 struct CppType<ObjectType, ObjectType::ePipelineLayout>
4013 {
4014 using Type = PipelineLayout;
4015 };
4016
4017 template <>
4018 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::ePipelineLayout>
4019 {
4020 using Type = PipelineLayout;
4021 };
4022
4023 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
4024 template <>
4025 struct CppType<VkPipelineLayout, VK_NULL_HANDLE>
4026 {
4027 using Type = PipelineLayout;
4028 };
4029 #endif
4030
4031 template <>
4032 struct isVulkanHandleType<PipelineLayout>
4033 {
4034 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
4035 };
4036
4037 // wrapper class for handle VkDescriptorSet, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorSet.html
4038 class DescriptorSet
4039 {
4040 public:
4041 using CType = VkDescriptorSet;
4042 using NativeType = VkDescriptorSet;
4043
4044 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDescriptorSet;
4045 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eDescriptorSet;
4046
4047 public:
4048 DescriptorSet() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
4049
4050 DescriptorSet( DescriptorSet const & rhs ) = default;
4051 DescriptorSet & operator=( DescriptorSet const & rhs ) = default;
4052
4053 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
4054 DescriptorSet( DescriptorSet && rhs ) = default;
4055 DescriptorSet & operator=( DescriptorSet && rhs ) = default;
4056 #else
4057 DescriptorSet( DescriptorSet && rhs ) VULKAN_HPP_NOEXCEPT : m_descriptorSet( exchange( rhs.m_descriptorSet, {} ) ) {}
4058
4059 DescriptorSet & operator=( DescriptorSet && rhs ) VULKAN_HPP_NOEXCEPT
4060 {
4061 m_descriptorSet = exchange( rhs.m_descriptorSet, {} );
4062 return *this;
4063 }
4064 #endif
4065
4066 VULKAN_HPP_CONSTEXPR DescriptorSet( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
4067
4068 VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSet( VkDescriptorSet descriptorSet ) VULKAN_HPP_NOEXCEPT : m_descriptorSet( descriptorSet ) {}
4069
4070 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
4071 DescriptorSet & operator=( VkDescriptorSet descriptorSet ) VULKAN_HPP_NOEXCEPT
4072 {
4073 m_descriptorSet = descriptorSet;
4074 return *this;
4075 }
4076 #endif
4077
4078 DescriptorSet & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
4079 {
4080 m_descriptorSet = {};
4081 return *this;
4082 }
4083
4084 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorSet() const VULKAN_HPP_NOEXCEPT
4085 {
4086 return m_descriptorSet;
4087 }
4088
4089 explicit operator bool() const VULKAN_HPP_NOEXCEPT
4090 {
4091 return m_descriptorSet != VK_NULL_HANDLE;
4092 }
4093
4094 bool operator!() const VULKAN_HPP_NOEXCEPT
4095 {
4096 return m_descriptorSet == VK_NULL_HANDLE;
4097 }
4098
4099 private:
4100 VkDescriptorSet m_descriptorSet = {};
4101 };
4102
4103 template <>
4104 struct CppType<ObjectType, ObjectType::eDescriptorSet>
4105 {
4106 using Type = DescriptorSet;
4107 };
4108
4109 template <>
4110 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eDescriptorSet>
4111 {
4112 using Type = DescriptorSet;
4113 };
4114
4115 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
4116 template <>
4117 struct CppType<VkDescriptorSet, VK_NULL_HANDLE>
4118 {
4119 using Type = DescriptorSet;
4120 };
4121 #endif
4122
4123 template <>
4124 struct isVulkanHandleType<DescriptorSet>
4125 {
4126 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
4127 };
4128
4129 // wrapper class for handle VkImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageView.html
4130 class ImageView
4131 {
4132 public:
4133 using CType = VkImageView;
4134 using NativeType = VkImageView;
4135
4136 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eImageView;
4137 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eImageView;
4138
4139 public:
4140 ImageView() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
4141
4142 ImageView( ImageView const & rhs ) = default;
4143 ImageView & operator=( ImageView const & rhs ) = default;
4144
4145 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
4146 ImageView( ImageView && rhs ) = default;
4147 ImageView & operator=( ImageView && rhs ) = default;
4148 #else
4149 ImageView( ImageView && rhs ) VULKAN_HPP_NOEXCEPT : m_imageView( exchange( rhs.m_imageView, {} ) ) {}
4150
4151 ImageView & operator=( ImageView && rhs ) VULKAN_HPP_NOEXCEPT
4152 {
4153 m_imageView = exchange( rhs.m_imageView, {} );
4154 return *this;
4155 }
4156 #endif
4157
4158 VULKAN_HPP_CONSTEXPR ImageView( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
4159
4160 VULKAN_HPP_TYPESAFE_EXPLICIT ImageView( VkImageView imageView ) VULKAN_HPP_NOEXCEPT : m_imageView( imageView ) {}
4161
4162 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
4163 ImageView & operator=( VkImageView imageView ) VULKAN_HPP_NOEXCEPT
4164 {
4165 m_imageView = imageView;
4166 return *this;
4167 }
4168 #endif
4169
4170 ImageView & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
4171 {
4172 m_imageView = {};
4173 return *this;
4174 }
4175
4176 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkImageView() const VULKAN_HPP_NOEXCEPT
4177 {
4178 return m_imageView;
4179 }
4180
4181 explicit operator bool() const VULKAN_HPP_NOEXCEPT
4182 {
4183 return m_imageView != VK_NULL_HANDLE;
4184 }
4185
4186 bool operator!() const VULKAN_HPP_NOEXCEPT
4187 {
4188 return m_imageView == VK_NULL_HANDLE;
4189 }
4190
4191 private:
4192 VkImageView m_imageView = {};
4193 };
4194
4195 template <>
4196 struct CppType<ObjectType, ObjectType::eImageView>
4197 {
4198 using Type = ImageView;
4199 };
4200
4201 template <>
4202 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eImageView>
4203 {
4204 using Type = ImageView;
4205 };
4206
4207 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
4208 template <>
4209 struct CppType<VkImageView, VK_NULL_HANDLE>
4210 {
4211 using Type = ImageView;
4212 };
4213 #endif
4214
4215 template <>
4216 struct isVulkanHandleType<ImageView>
4217 {
4218 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
4219 };
4220
4221 // wrapper class for handle VkPipeline, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipeline.html
4222 class Pipeline
4223 {
4224 public:
4225 using CType = VkPipeline;
4226 using NativeType = VkPipeline;
4227
4228 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePipeline;
4229 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::ePipeline;
4230
4231 public:
4232 Pipeline() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
4233
4234 Pipeline( Pipeline const & rhs ) = default;
4235 Pipeline & operator=( Pipeline const & rhs ) = default;
4236
4237 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
4238 Pipeline( Pipeline && rhs ) = default;
4239 Pipeline & operator=( Pipeline && rhs ) = default;
4240 #else
4241 Pipeline( Pipeline && rhs ) VULKAN_HPP_NOEXCEPT : m_pipeline( exchange( rhs.m_pipeline, {} ) ) {}
4242
4243 Pipeline & operator=( Pipeline && rhs ) VULKAN_HPP_NOEXCEPT
4244 {
4245 m_pipeline = exchange( rhs.m_pipeline, {} );
4246 return *this;
4247 }
4248 #endif
4249
4250 VULKAN_HPP_CONSTEXPR Pipeline( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
4251
4252 VULKAN_HPP_TYPESAFE_EXPLICIT Pipeline( VkPipeline pipeline ) VULKAN_HPP_NOEXCEPT : m_pipeline( pipeline ) {}
4253
4254 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
4255 Pipeline & operator=( VkPipeline pipeline ) VULKAN_HPP_NOEXCEPT
4256 {
4257 m_pipeline = pipeline;
4258 return *this;
4259 }
4260 #endif
4261
4262 Pipeline & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
4263 {
4264 m_pipeline = {};
4265 return *this;
4266 }
4267
4268 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipeline() const VULKAN_HPP_NOEXCEPT
4269 {
4270 return m_pipeline;
4271 }
4272
4273 explicit operator bool() const VULKAN_HPP_NOEXCEPT
4274 {
4275 return m_pipeline != VK_NULL_HANDLE;
4276 }
4277
4278 bool operator!() const VULKAN_HPP_NOEXCEPT
4279 {
4280 return m_pipeline == VK_NULL_HANDLE;
4281 }
4282
4283 private:
4284 VkPipeline m_pipeline = {};
4285 };
4286
4287 template <>
4288 struct CppType<ObjectType, ObjectType::ePipeline>
4289 {
4290 using Type = Pipeline;
4291 };
4292
4293 template <>
4294 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::ePipeline>
4295 {
4296 using Type = Pipeline;
4297 };
4298
4299 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
4300 template <>
4301 struct CppType<VkPipeline, VK_NULL_HANDLE>
4302 {
4303 using Type = Pipeline;
4304 };
4305 #endif
4306
4307 template <>
4308 struct isVulkanHandleType<Pipeline>
4309 {
4310 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
4311 };
4312
4313 // wrapper class for handle VkShaderEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderEXT.html
4314 class ShaderEXT
4315 {
4316 public:
4317 using CType = VkShaderEXT;
4318 using NativeType = VkShaderEXT;
4319
4320 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eShaderEXT;
4321 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown;
4322
4323 public:
4324 ShaderEXT() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
4325
4326 ShaderEXT( ShaderEXT const & rhs ) = default;
4327 ShaderEXT & operator=( ShaderEXT const & rhs ) = default;
4328
4329 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
4330 ShaderEXT( ShaderEXT && rhs ) = default;
4331 ShaderEXT & operator=( ShaderEXT && rhs ) = default;
4332 #else
4333 ShaderEXT( ShaderEXT && rhs ) VULKAN_HPP_NOEXCEPT : m_shaderEXT( exchange( rhs.m_shaderEXT, {} ) ) {}
4334
4335 ShaderEXT & operator=( ShaderEXT && rhs ) VULKAN_HPP_NOEXCEPT
4336 {
4337 m_shaderEXT = exchange( rhs.m_shaderEXT, {} );
4338 return *this;
4339 }
4340 #endif
4341
4342 VULKAN_HPP_CONSTEXPR ShaderEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
4343
4344 VULKAN_HPP_TYPESAFE_EXPLICIT ShaderEXT( VkShaderEXT shaderEXT ) VULKAN_HPP_NOEXCEPT : m_shaderEXT( shaderEXT ) {}
4345
4346 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
4347 ShaderEXT & operator=( VkShaderEXT shaderEXT ) VULKAN_HPP_NOEXCEPT
4348 {
4349 m_shaderEXT = shaderEXT;
4350 return *this;
4351 }
4352 #endif
4353
4354 ShaderEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
4355 {
4356 m_shaderEXT = {};
4357 return *this;
4358 }
4359
4360 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkShaderEXT() const VULKAN_HPP_NOEXCEPT
4361 {
4362 return m_shaderEXT;
4363 }
4364
4365 explicit operator bool() const VULKAN_HPP_NOEXCEPT
4366 {
4367 return m_shaderEXT != VK_NULL_HANDLE;
4368 }
4369
4370 bool operator!() const VULKAN_HPP_NOEXCEPT
4371 {
4372 return m_shaderEXT == VK_NULL_HANDLE;
4373 }
4374
4375 private:
4376 VkShaderEXT m_shaderEXT = {};
4377 };
4378
4379 template <>
4380 struct CppType<ObjectType, ObjectType::eShaderEXT>
4381 {
4382 using Type = ShaderEXT;
4383 };
4384
4385 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
4386 template <>
4387 struct CppType<VkShaderEXT, VK_NULL_HANDLE>
4388 {
4389 using Type = ShaderEXT;
4390 };
4391 #endif
4392
4393 template <>
4394 struct isVulkanHandleType<ShaderEXT>
4395 {
4396 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
4397 };
4398
4399 // wrapper class for handle VkAccelerationStructureNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureNV.html
4400 class AccelerationStructureNV
4401 {
4402 public:
4403 using CType = VkAccelerationStructureNV;
4404 using NativeType = VkAccelerationStructureNV;
4405
4406 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eAccelerationStructureNV;
4407 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eAccelerationStructureNV;
4408
4409 public:
4410 AccelerationStructureNV() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
4411
4412 AccelerationStructureNV( AccelerationStructureNV const & rhs ) = default;
4413 AccelerationStructureNV & operator=( AccelerationStructureNV const & rhs ) = default;
4414
4415 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
4416 AccelerationStructureNV( AccelerationStructureNV && rhs ) = default;
4417 AccelerationStructureNV & operator=( AccelerationStructureNV && rhs ) = default;
4418 #else
4419 AccelerationStructureNV( AccelerationStructureNV && rhs ) VULKAN_HPP_NOEXCEPT : m_accelerationStructureNV( exchange( rhs.m_accelerationStructureNV, {} ) )
4420 {
4421 }
4422
4423 AccelerationStructureNV & operator=( AccelerationStructureNV && rhs ) VULKAN_HPP_NOEXCEPT
4424 {
4425 m_accelerationStructureNV = exchange( rhs.m_accelerationStructureNV, {} );
4426 return *this;
4427 }
4428 #endif
4429
4430 VULKAN_HPP_CONSTEXPR AccelerationStructureNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
4431
4432 VULKAN_HPP_TYPESAFE_EXPLICIT AccelerationStructureNV( VkAccelerationStructureNV accelerationStructureNV ) VULKAN_HPP_NOEXCEPT
4433 : m_accelerationStructureNV( accelerationStructureNV )
4434 {
4435 }
4436
4437 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
4438 AccelerationStructureNV & operator=( VkAccelerationStructureNV accelerationStructureNV ) VULKAN_HPP_NOEXCEPT
4439 {
4440 m_accelerationStructureNV = accelerationStructureNV;
4441 return *this;
4442 }
4443 #endif
4444
4445 AccelerationStructureNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
4446 {
4447 m_accelerationStructureNV = {};
4448 return *this;
4449 }
4450
4451 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkAccelerationStructureNV() const VULKAN_HPP_NOEXCEPT
4452 {
4453 return m_accelerationStructureNV;
4454 }
4455
4456 explicit operator bool() const VULKAN_HPP_NOEXCEPT
4457 {
4458 return m_accelerationStructureNV != VK_NULL_HANDLE;
4459 }
4460
4461 bool operator!() const VULKAN_HPP_NOEXCEPT
4462 {
4463 return m_accelerationStructureNV == VK_NULL_HANDLE;
4464 }
4465
4466 private:
4467 VkAccelerationStructureNV m_accelerationStructureNV = {};
4468 };
4469
4470 template <>
4471 struct CppType<ObjectType, ObjectType::eAccelerationStructureNV>
4472 {
4473 using Type = AccelerationStructureNV;
4474 };
4475
4476 template <>
4477 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eAccelerationStructureNV>
4478 {
4479 using Type = AccelerationStructureNV;
4480 };
4481
4482 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
4483 template <>
4484 struct CppType<VkAccelerationStructureNV, VK_NULL_HANDLE>
4485 {
4486 using Type = AccelerationStructureNV;
4487 };
4488 #endif
4489
4490 template <>
4491 struct isVulkanHandleType<AccelerationStructureNV>
4492 {
4493 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
4494 };
4495
4496 // wrapper class for handle VkDataGraphPipelineSessionARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineSessionARM.html
4497 class DataGraphPipelineSessionARM
4498 {
4499 public:
4500 using CType = VkDataGraphPipelineSessionARM;
4501 using NativeType = VkDataGraphPipelineSessionARM;
4502
4503 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDataGraphPipelineSessionARM;
4504 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown;
4505
4506 public:
4507 DataGraphPipelineSessionARM() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
4508
4509 DataGraphPipelineSessionARM( DataGraphPipelineSessionARM const & rhs ) = default;
4510 DataGraphPipelineSessionARM & operator=( DataGraphPipelineSessionARM const & rhs ) = default;
4511
4512 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
4513 DataGraphPipelineSessionARM( DataGraphPipelineSessionARM && rhs ) = default;
4514 DataGraphPipelineSessionARM & operator=( DataGraphPipelineSessionARM && rhs ) = default;
4515 #else
4516 DataGraphPipelineSessionARM( DataGraphPipelineSessionARM && rhs ) VULKAN_HPP_NOEXCEPT
4517 : m_dataGraphPipelineSessionARM( exchange( rhs.m_dataGraphPipelineSessionARM, {} ) )
4518 {
4519 }
4520
4521 DataGraphPipelineSessionARM & operator=( DataGraphPipelineSessionARM && rhs ) VULKAN_HPP_NOEXCEPT
4522 {
4523 m_dataGraphPipelineSessionARM = exchange( rhs.m_dataGraphPipelineSessionARM, {} );
4524 return *this;
4525 }
4526 #endif
4527
4528 VULKAN_HPP_CONSTEXPR DataGraphPipelineSessionARM( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
4529
4530 VULKAN_HPP_TYPESAFE_EXPLICIT DataGraphPipelineSessionARM( VkDataGraphPipelineSessionARM dataGraphPipelineSessionARM ) VULKAN_HPP_NOEXCEPT
4531 : m_dataGraphPipelineSessionARM( dataGraphPipelineSessionARM )
4532 {
4533 }
4534
4535 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
4536 DataGraphPipelineSessionARM & operator=( VkDataGraphPipelineSessionARM dataGraphPipelineSessionARM ) VULKAN_HPP_NOEXCEPT
4537 {
4538 m_dataGraphPipelineSessionARM = dataGraphPipelineSessionARM;
4539 return *this;
4540 }
4541 #endif
4542
4543 DataGraphPipelineSessionARM & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
4544 {
4545 m_dataGraphPipelineSessionARM = {};
4546 return *this;
4547 }
4548
4549 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDataGraphPipelineSessionARM() const VULKAN_HPP_NOEXCEPT
4550 {
4551 return m_dataGraphPipelineSessionARM;
4552 }
4553
4554 explicit operator bool() const VULKAN_HPP_NOEXCEPT
4555 {
4556 return m_dataGraphPipelineSessionARM != VK_NULL_HANDLE;
4557 }
4558
4559 bool operator!() const VULKAN_HPP_NOEXCEPT
4560 {
4561 return m_dataGraphPipelineSessionARM == VK_NULL_HANDLE;
4562 }
4563
4564 private:
4565 VkDataGraphPipelineSessionARM m_dataGraphPipelineSessionARM = {};
4566 };
4567
4568 template <>
4569 struct CppType<ObjectType, ObjectType::eDataGraphPipelineSessionARM>
4570 {
4571 using Type = DataGraphPipelineSessionARM;
4572 };
4573
4574 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
4575 template <>
4576 struct CppType<VkDataGraphPipelineSessionARM, VK_NULL_HANDLE>
4577 {
4578 using Type = DataGraphPipelineSessionARM;
4579 };
4580 #endif
4581
4582 template <>
4583 struct isVulkanHandleType<DataGraphPipelineSessionARM>
4584 {
4585 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
4586 };
4587
4588 // wrapper class for handle VkOpticalFlowSessionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkOpticalFlowSessionNV.html
4589 class OpticalFlowSessionNV
4590 {
4591 public:
4592 using CType = VkOpticalFlowSessionNV;
4593 using NativeType = VkOpticalFlowSessionNV;
4594
4595 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eOpticalFlowSessionNV;
4596 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown;
4597
4598 public:
4599 OpticalFlowSessionNV() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
4600
4601 OpticalFlowSessionNV( OpticalFlowSessionNV const & rhs ) = default;
4602 OpticalFlowSessionNV & operator=( OpticalFlowSessionNV const & rhs ) = default;
4603
4604 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
4605 OpticalFlowSessionNV( OpticalFlowSessionNV && rhs ) = default;
4606 OpticalFlowSessionNV & operator=( OpticalFlowSessionNV && rhs ) = default;
4607 #else
4608 OpticalFlowSessionNV( OpticalFlowSessionNV && rhs ) VULKAN_HPP_NOEXCEPT : m_opticalFlowSessionNV( exchange( rhs.m_opticalFlowSessionNV, {} ) ) {}
4609
4610 OpticalFlowSessionNV & operator=( OpticalFlowSessionNV && rhs ) VULKAN_HPP_NOEXCEPT
4611 {
4612 m_opticalFlowSessionNV = exchange( rhs.m_opticalFlowSessionNV, {} );
4613 return *this;
4614 }
4615 #endif
4616
4617 VULKAN_HPP_CONSTEXPR OpticalFlowSessionNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
4618
4619 VULKAN_HPP_TYPESAFE_EXPLICIT OpticalFlowSessionNV( VkOpticalFlowSessionNV opticalFlowSessionNV ) VULKAN_HPP_NOEXCEPT
4620 : m_opticalFlowSessionNV( opticalFlowSessionNV )
4621 {
4622 }
4623
4624 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
4625 OpticalFlowSessionNV & operator=( VkOpticalFlowSessionNV opticalFlowSessionNV ) VULKAN_HPP_NOEXCEPT
4626 {
4627 m_opticalFlowSessionNV = opticalFlowSessionNV;
4628 return *this;
4629 }
4630 #endif
4631
4632 OpticalFlowSessionNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
4633 {
4634 m_opticalFlowSessionNV = {};
4635 return *this;
4636 }
4637
4638 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkOpticalFlowSessionNV() const VULKAN_HPP_NOEXCEPT
4639 {
4640 return m_opticalFlowSessionNV;
4641 }
4642
4643 explicit operator bool() const VULKAN_HPP_NOEXCEPT
4644 {
4645 return m_opticalFlowSessionNV != VK_NULL_HANDLE;
4646 }
4647
4648 bool operator!() const VULKAN_HPP_NOEXCEPT
4649 {
4650 return m_opticalFlowSessionNV == VK_NULL_HANDLE;
4651 }
4652
4653 private:
4654 VkOpticalFlowSessionNV m_opticalFlowSessionNV = {};
4655 };
4656
4657 template <>
4658 struct CppType<ObjectType, ObjectType::eOpticalFlowSessionNV>
4659 {
4660 using Type = OpticalFlowSessionNV;
4661 };
4662
4663 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
4664 template <>
4665 struct CppType<VkOpticalFlowSessionNV, VK_NULL_HANDLE>
4666 {
4667 using Type = OpticalFlowSessionNV;
4668 };
4669 #endif
4670
4671 template <>
4672 struct isVulkanHandleType<OpticalFlowSessionNV>
4673 {
4674 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
4675 };
4676
4677 // wrapper class for handle VkDescriptorUpdateTemplate, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorUpdateTemplate.html
4678 class DescriptorUpdateTemplate
4679 {
4680 public:
4681 using CType = VkDescriptorUpdateTemplate;
4682 using NativeType = VkDescriptorUpdateTemplate;
4683
4684 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDescriptorUpdateTemplate;
4685 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eDescriptorUpdateTemplate;
4686
4687 public:
4688 DescriptorUpdateTemplate() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
4689
4690 DescriptorUpdateTemplate( DescriptorUpdateTemplate const & rhs ) = default;
4691 DescriptorUpdateTemplate & operator=( DescriptorUpdateTemplate const & rhs ) = default;
4692
4693 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
4694 DescriptorUpdateTemplate( DescriptorUpdateTemplate && rhs ) = default;
4695 DescriptorUpdateTemplate & operator=( DescriptorUpdateTemplate && rhs ) = default;
4696 #else
4697 DescriptorUpdateTemplate( DescriptorUpdateTemplate && rhs ) VULKAN_HPP_NOEXCEPT
4698 : m_descriptorUpdateTemplate( exchange( rhs.m_descriptorUpdateTemplate, {} ) )
4699 {
4700 }
4701
4702 DescriptorUpdateTemplate & operator=( DescriptorUpdateTemplate && rhs ) VULKAN_HPP_NOEXCEPT
4703 {
4704 m_descriptorUpdateTemplate = exchange( rhs.m_descriptorUpdateTemplate, {} );
4705 return *this;
4706 }
4707 #endif
4708
4709 VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplate( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
4710
4711 VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorUpdateTemplate( VkDescriptorUpdateTemplate descriptorUpdateTemplate ) VULKAN_HPP_NOEXCEPT
4712 : m_descriptorUpdateTemplate( descriptorUpdateTemplate )
4713 {
4714 }
4715
4716 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
4717 DescriptorUpdateTemplate & operator=( VkDescriptorUpdateTemplate descriptorUpdateTemplate ) VULKAN_HPP_NOEXCEPT
4718 {
4719 m_descriptorUpdateTemplate = descriptorUpdateTemplate;
4720 return *this;
4721 }
4722 #endif
4723
4724 DescriptorUpdateTemplate & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
4725 {
4726 m_descriptorUpdateTemplate = {};
4727 return *this;
4728 }
4729
4730 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorUpdateTemplate() const VULKAN_HPP_NOEXCEPT
4731 {
4732 return m_descriptorUpdateTemplate;
4733 }
4734
4735 explicit operator bool() const VULKAN_HPP_NOEXCEPT
4736 {
4737 return m_descriptorUpdateTemplate != VK_NULL_HANDLE;
4738 }
4739
4740 bool operator!() const VULKAN_HPP_NOEXCEPT
4741 {
4742 return m_descriptorUpdateTemplate == VK_NULL_HANDLE;
4743 }
4744
4745 private:
4746 VkDescriptorUpdateTemplate m_descriptorUpdateTemplate = {};
4747 };
4748
4749 template <>
4750 struct CppType<ObjectType, ObjectType::eDescriptorUpdateTemplate>
4751 {
4752 using Type = DescriptorUpdateTemplate;
4753 };
4754
4755 template <>
4756 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eDescriptorUpdateTemplate>
4757 {
4758 using Type = DescriptorUpdateTemplate;
4759 };
4760
4761 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
4762 template <>
4763 struct CppType<VkDescriptorUpdateTemplate, VK_NULL_HANDLE>
4764 {
4765 using Type = DescriptorUpdateTemplate;
4766 };
4767 #endif
4768
4769 template <>
4770 struct isVulkanHandleType<DescriptorUpdateTemplate>
4771 {
4772 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
4773 };
4774
4775 using DescriptorUpdateTemplateKHR = DescriptorUpdateTemplate;
4776
4777 // wrapper class for handle VkEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkEvent.html
4778 class Event
4779 {
4780 public:
4781 using CType = VkEvent;
4782 using NativeType = VkEvent;
4783
4784 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eEvent;
4785 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eEvent;
4786
4787 public:
4788 Event() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
4789
4790 Event( Event const & rhs ) = default;
4791 Event & operator=( Event const & rhs ) = default;
4792
4793 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
4794 Event( Event && rhs ) = default;
4795 Event & operator=( Event && rhs ) = default;
4796 #else
4797 Event( Event && rhs ) VULKAN_HPP_NOEXCEPT : m_event( exchange( rhs.m_event, {} ) ) {}
4798
4799 Event & operator=( Event && rhs ) VULKAN_HPP_NOEXCEPT
4800 {
4801 m_event = exchange( rhs.m_event, {} );
4802 return *this;
4803 }
4804 #endif
4805
4806 VULKAN_HPP_CONSTEXPR Event( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
4807
4808 VULKAN_HPP_TYPESAFE_EXPLICIT Event( VkEvent event ) VULKAN_HPP_NOEXCEPT : m_event( event ) {}
4809
4810 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
4811 Event & operator=( VkEvent event ) VULKAN_HPP_NOEXCEPT
4812 {
4813 m_event = event;
4814 return *this;
4815 }
4816 #endif
4817
4818 Event & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
4819 {
4820 m_event = {};
4821 return *this;
4822 }
4823
4824 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkEvent() const VULKAN_HPP_NOEXCEPT
4825 {
4826 return m_event;
4827 }
4828
4829 explicit operator bool() const VULKAN_HPP_NOEXCEPT
4830 {
4831 return m_event != VK_NULL_HANDLE;
4832 }
4833
4834 bool operator!() const VULKAN_HPP_NOEXCEPT
4835 {
4836 return m_event == VK_NULL_HANDLE;
4837 }
4838
4839 private:
4840 VkEvent m_event = {};
4841 };
4842
4843 template <>
4844 struct CppType<ObjectType, ObjectType::eEvent>
4845 {
4846 using Type = Event;
4847 };
4848
4849 template <>
4850 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eEvent>
4851 {
4852 using Type = Event;
4853 };
4854
4855 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
4856 template <>
4857 struct CppType<VkEvent, VK_NULL_HANDLE>
4858 {
4859 using Type = Event;
4860 };
4861 #endif
4862
4863 template <>
4864 struct isVulkanHandleType<Event>
4865 {
4866 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
4867 };
4868
4869 // wrapper class for handle VkAccelerationStructureKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureKHR.html
4870 class AccelerationStructureKHR
4871 {
4872 public:
4873 using CType = VkAccelerationStructureKHR;
4874 using NativeType = VkAccelerationStructureKHR;
4875
4876 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eAccelerationStructureKHR;
4877 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eAccelerationStructureKHR;
4878
4879 public:
4880 AccelerationStructureKHR() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
4881
4882 AccelerationStructureKHR( AccelerationStructureKHR const & rhs ) = default;
4883 AccelerationStructureKHR & operator=( AccelerationStructureKHR const & rhs ) = default;
4884
4885 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
4886 AccelerationStructureKHR( AccelerationStructureKHR && rhs ) = default;
4887 AccelerationStructureKHR & operator=( AccelerationStructureKHR && rhs ) = default;
4888 #else
4889 AccelerationStructureKHR( AccelerationStructureKHR && rhs ) VULKAN_HPP_NOEXCEPT
4890 : m_accelerationStructureKHR( exchange( rhs.m_accelerationStructureKHR, {} ) )
4891 {
4892 }
4893
4894 AccelerationStructureKHR & operator=( AccelerationStructureKHR && rhs ) VULKAN_HPP_NOEXCEPT
4895 {
4896 m_accelerationStructureKHR = exchange( rhs.m_accelerationStructureKHR, {} );
4897 return *this;
4898 }
4899 #endif
4900
4901 VULKAN_HPP_CONSTEXPR AccelerationStructureKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
4902
4903 VULKAN_HPP_TYPESAFE_EXPLICIT AccelerationStructureKHR( VkAccelerationStructureKHR accelerationStructureKHR ) VULKAN_HPP_NOEXCEPT
4904 : m_accelerationStructureKHR( accelerationStructureKHR )
4905 {
4906 }
4907
4908 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
4909 AccelerationStructureKHR & operator=( VkAccelerationStructureKHR accelerationStructureKHR ) VULKAN_HPP_NOEXCEPT
4910 {
4911 m_accelerationStructureKHR = accelerationStructureKHR;
4912 return *this;
4913 }
4914 #endif
4915
4916 AccelerationStructureKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
4917 {
4918 m_accelerationStructureKHR = {};
4919 return *this;
4920 }
4921
4922 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkAccelerationStructureKHR() const VULKAN_HPP_NOEXCEPT
4923 {
4924 return m_accelerationStructureKHR;
4925 }
4926
4927 explicit operator bool() const VULKAN_HPP_NOEXCEPT
4928 {
4929 return m_accelerationStructureKHR != VK_NULL_HANDLE;
4930 }
4931
4932 bool operator!() const VULKAN_HPP_NOEXCEPT
4933 {
4934 return m_accelerationStructureKHR == VK_NULL_HANDLE;
4935 }
4936
4937 private:
4938 VkAccelerationStructureKHR m_accelerationStructureKHR = {};
4939 };
4940
4941 template <>
4942 struct CppType<ObjectType, ObjectType::eAccelerationStructureKHR>
4943 {
4944 using Type = AccelerationStructureKHR;
4945 };
4946
4947 template <>
4948 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eAccelerationStructureKHR>
4949 {
4950 using Type = AccelerationStructureKHR;
4951 };
4952
4953 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
4954 template <>
4955 struct CppType<VkAccelerationStructureKHR, VK_NULL_HANDLE>
4956 {
4957 using Type = AccelerationStructureKHR;
4958 };
4959 #endif
4960
4961 template <>
4962 struct isVulkanHandleType<AccelerationStructureKHR>
4963 {
4964 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
4965 };
4966
4967 // wrapper class for handle VkMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMicromapEXT.html
4968 class MicromapEXT
4969 {
4970 public:
4971 using CType = VkMicromapEXT;
4972 using NativeType = VkMicromapEXT;
4973
4974 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eMicromapEXT;
4975 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown;
4976
4977 public:
4978 MicromapEXT() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
4979
4980 MicromapEXT( MicromapEXT const & rhs ) = default;
4981 MicromapEXT & operator=( MicromapEXT const & rhs ) = default;
4982
4983 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
4984 MicromapEXT( MicromapEXT && rhs ) = default;
4985 MicromapEXT & operator=( MicromapEXT && rhs ) = default;
4986 #else
4987 MicromapEXT( MicromapEXT && rhs ) VULKAN_HPP_NOEXCEPT : m_micromapEXT( exchange( rhs.m_micromapEXT, {} ) ) {}
4988
4989 MicromapEXT & operator=( MicromapEXT && rhs ) VULKAN_HPP_NOEXCEPT
4990 {
4991 m_micromapEXT = exchange( rhs.m_micromapEXT, {} );
4992 return *this;
4993 }
4994 #endif
4995
4996 VULKAN_HPP_CONSTEXPR MicromapEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
4997
4998 VULKAN_HPP_TYPESAFE_EXPLICIT MicromapEXT( VkMicromapEXT micromapEXT ) VULKAN_HPP_NOEXCEPT : m_micromapEXT( micromapEXT ) {}
4999
5000 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
5001 MicromapEXT & operator=( VkMicromapEXT micromapEXT ) VULKAN_HPP_NOEXCEPT
5002 {
5003 m_micromapEXT = micromapEXT;
5004 return *this;
5005 }
5006 #endif
5007
5008 MicromapEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5009 {
5010 m_micromapEXT = {};
5011 return *this;
5012 }
5013
5014 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkMicromapEXT() const VULKAN_HPP_NOEXCEPT
5015 {
5016 return m_micromapEXT;
5017 }
5018
5019 explicit operator bool() const VULKAN_HPP_NOEXCEPT
5020 {
5021 return m_micromapEXT != VK_NULL_HANDLE;
5022 }
5023
5024 bool operator!() const VULKAN_HPP_NOEXCEPT
5025 {
5026 return m_micromapEXT == VK_NULL_HANDLE;
5027 }
5028
5029 private:
5030 VkMicromapEXT m_micromapEXT = {};
5031 };
5032
5033 template <>
5034 struct CppType<ObjectType, ObjectType::eMicromapEXT>
5035 {
5036 using Type = MicromapEXT;
5037 };
5038
5039 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
5040 template <>
5041 struct CppType<VkMicromapEXT, VK_NULL_HANDLE>
5042 {
5043 using Type = MicromapEXT;
5044 };
5045 #endif
5046
5047 template <>
5048 struct isVulkanHandleType<MicromapEXT>
5049 {
5050 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
5051 };
5052
5053 // wrapper class for handle VkCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandBuffer.html
5054 class CommandBuffer
5055 {
5056 public:
5057 using CType = VkCommandBuffer;
5058 using NativeType = VkCommandBuffer;
5059
5060 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eCommandBuffer;
5061 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eCommandBuffer;
5062
5063 public:
5064 CommandBuffer() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
5065
5066 CommandBuffer( CommandBuffer const & rhs ) = default;
5067 CommandBuffer & operator=( CommandBuffer const & rhs ) = default;
5068
5069 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
5070 CommandBuffer( CommandBuffer && rhs ) = default;
5071 CommandBuffer & operator=( CommandBuffer && rhs ) = default;
5072 #else
5073 CommandBuffer( CommandBuffer && rhs ) VULKAN_HPP_NOEXCEPT : m_commandBuffer( exchange( rhs.m_commandBuffer, {} ) ) {}
5074
5075 CommandBuffer & operator=( CommandBuffer && rhs ) VULKAN_HPP_NOEXCEPT
5076 {
5077 m_commandBuffer = exchange( rhs.m_commandBuffer, {} );
5078 return *this;
5079 }
5080 #endif
5081
5082 VULKAN_HPP_CONSTEXPR CommandBuffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
5083
5084 CommandBuffer( VkCommandBuffer commandBuffer ) VULKAN_HPP_NOEXCEPT : m_commandBuffer( commandBuffer ) {}
5085
5086 CommandBuffer & operator=( VkCommandBuffer commandBuffer ) VULKAN_HPP_NOEXCEPT
5087 {
5088 m_commandBuffer = commandBuffer;
5089 return *this;
5090 }
5091
5092 CommandBuffer & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5093 {
5094 m_commandBuffer = {};
5095 return *this;
5096 }
5097
5098 //=== VK_VERSION_1_0 ===
5099
5100 // wrapper function for command vkBeginCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBeginCommandBuffer.html
5101 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5102 VULKAN_HPP_NODISCARD Result begin( const CommandBufferBeginInfo * pBeginInfo,
5103 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5104 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5105 // wrapper function for command vkBeginCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBeginCommandBuffer.html
5106 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5107 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type begin( const CommandBufferBeginInfo & beginInfo,
5108 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
5109 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5110
5111 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
5112 // wrapper function for command vkEndCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEndCommandBuffer.html
5113 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5114 VULKAN_HPP_NODISCARD Result end( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5115 #else
5116 // wrapper function for command vkEndCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEndCommandBuffer.html
5117 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5118 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type end( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
5119 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
5120
5121 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
5122 // wrapper function for command vkResetCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetCommandBuffer.html
5123 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5124 VULKAN_HPP_NODISCARD Result reset( CommandBufferResetFlags flags, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5125 #else
5126 // wrapper function for command vkResetCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetCommandBuffer.html
5127 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5128 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type reset( CommandBufferResetFlags flags VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
5129 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
5130 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
5131
5132 // wrapper function for command vkCmdCopyBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBuffer.html
5133 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5134 void copyBuffer( Buffer srcBuffer,
5135 Buffer dstBuffer,
5136 uint32_t regionCount,
5137 const BufferCopy * pRegions,
5138 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5139 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5140 // wrapper function for command vkCmdCopyBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBuffer.html
5141 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5142 void copyBuffer( Buffer srcBuffer,
5143 Buffer dstBuffer,
5144 ArrayProxy<const BufferCopy> const & regions,
5145 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5146 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5147
5148 // wrapper function for command vkCmdCopyImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImage.html
5149 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5150 void copyImage( Image srcImage,
5151 ImageLayout srcImageLayout,
5152 Image dstImage,
5153 ImageLayout dstImageLayout,
5154 uint32_t regionCount,
5155 const ImageCopy * pRegions,
5156 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5157 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5158 // wrapper function for command vkCmdCopyImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImage.html
5159 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5160 void copyImage( Image srcImage,
5161 ImageLayout srcImageLayout,
5162 Image dstImage,
5163 ImageLayout dstImageLayout,
5164 ArrayProxy<const ImageCopy> const & regions,
5165 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5166 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5167
5168 // wrapper function for command vkCmdCopyBufferToImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBufferToImage.html
5169 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5170 void copyBufferToImage( Buffer srcBuffer,
5171 Image dstImage,
5172 ImageLayout dstImageLayout,
5173 uint32_t regionCount,
5174 const BufferImageCopy * pRegions,
5175 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5176 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5177 // wrapper function for command vkCmdCopyBufferToImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBufferToImage.html
5178 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5179 void copyBufferToImage( Buffer srcBuffer,
5180 Image dstImage,
5181 ImageLayout dstImageLayout,
5182 ArrayProxy<const BufferImageCopy> const & regions,
5183 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5184 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5185
5186 // wrapper function for command vkCmdCopyImageToBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToBuffer.html
5187 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5188 void copyImageToBuffer( Image srcImage,
5189 ImageLayout srcImageLayout,
5190 Buffer dstBuffer,
5191 uint32_t regionCount,
5192 const BufferImageCopy * pRegions,
5193 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5194 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5195 // wrapper function for command vkCmdCopyImageToBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToBuffer.html
5196 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5197 void copyImageToBuffer( Image srcImage,
5198 ImageLayout srcImageLayout,
5199 Buffer dstBuffer,
5200 ArrayProxy<const BufferImageCopy> const & regions,
5201 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5202 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5203
5204 // wrapper function for command vkCmdUpdateBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdUpdateBuffer.html
5205 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5206 void updateBuffer( Buffer dstBuffer,
5207 DeviceSize dstOffset,
5208 DeviceSize dataSize,
5209 const void * pData,
5210 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5211 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5212 // wrapper function for command vkCmdUpdateBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdUpdateBuffer.html
5213 template <typename DataType,
5214 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
5215 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5216 void updateBuffer( Buffer dstBuffer,
5217 DeviceSize dstOffset,
5218 ArrayProxy<const DataType> const & data,
5219 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5220 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5221
5222 // wrapper function for command vkCmdFillBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdFillBuffer.html
5223 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5224 void fillBuffer( Buffer dstBuffer, DeviceSize dstOffset, DeviceSize size, uint32_t data, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
5225 VULKAN_HPP_NOEXCEPT;
5226
5227 // wrapper function for command vkCmdPipelineBarrier, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPipelineBarrier.html
5228 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5229 void pipelineBarrier( PipelineStageFlags srcStageMask,
5230 PipelineStageFlags dstStageMask,
5231 DependencyFlags dependencyFlags,
5232 uint32_t memoryBarrierCount,
5233 const MemoryBarrier * pMemoryBarriers,
5234 uint32_t bufferMemoryBarrierCount,
5235 const BufferMemoryBarrier * pBufferMemoryBarriers,
5236 uint32_t imageMemoryBarrierCount,
5237 const ImageMemoryBarrier * pImageMemoryBarriers,
5238 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5239 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5240 // wrapper function for command vkCmdPipelineBarrier, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPipelineBarrier.html
5241 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5242 void pipelineBarrier( PipelineStageFlags srcStageMask,
5243 PipelineStageFlags dstStageMask,
5244 DependencyFlags dependencyFlags,
5245 ArrayProxy<const MemoryBarrier> const & memoryBarriers,
5246 ArrayProxy<const BufferMemoryBarrier> const & bufferMemoryBarriers,
5247 ArrayProxy<const ImageMemoryBarrier> const & imageMemoryBarriers,
5248 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5249 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5250
5251 // wrapper function for command vkCmdBeginQuery, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginQuery.html
5252 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5253 void beginQuery( QueryPool queryPool,
5254 uint32_t query,
5255 QueryControlFlags flags,
5256 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5257
5258 // wrapper function for command vkCmdEndQuery, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndQuery.html
5259 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5260 void endQuery( QueryPool queryPool, uint32_t query, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5261
5262 // wrapper function for command vkCmdResetQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResetQueryPool.html
5263 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5264 void resetQueryPool( QueryPool queryPool,
5265 uint32_t firstQuery,
5266 uint32_t queryCount,
5267 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5268
5269 // wrapper function for command vkCmdWriteTimestamp, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteTimestamp.html
5270 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5271 void writeTimestamp( PipelineStageFlagBits pipelineStage,
5272 QueryPool queryPool,
5273 uint32_t query,
5274 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5275
5276 // wrapper function for command vkCmdCopyQueryPoolResults, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyQueryPoolResults.html
5277 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5278 void copyQueryPoolResults( QueryPool queryPool,
5279 uint32_t firstQuery,
5280 uint32_t queryCount,
5281 Buffer dstBuffer,
5282 DeviceSize dstOffset,
5283 DeviceSize stride,
5284 QueryResultFlags flags,
5285 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5286
5287 // wrapper function for command vkCmdExecuteCommands, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdExecuteCommands.html
5288 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5289 void executeCommands( uint32_t commandBufferCount,
5290 const CommandBuffer * pCommandBuffers,
5291 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5292 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5293 // wrapper function for command vkCmdExecuteCommands, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdExecuteCommands.html
5294 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5295 void executeCommands( ArrayProxy<const CommandBuffer> const & commandBuffers,
5296 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5297 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5298
5299 // wrapper function for command vkCmdBindPipeline, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindPipeline.html
5300 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5301 void bindPipeline( PipelineBindPoint pipelineBindPoint,
5302 Pipeline pipeline,
5303 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5304
5305 // wrapper function for command vkCmdBindDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorSets.html
5306 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5307 void bindDescriptorSets( PipelineBindPoint pipelineBindPoint,
5308 PipelineLayout layout,
5309 uint32_t firstSet,
5310 uint32_t descriptorSetCount,
5311 const DescriptorSet * pDescriptorSets,
5312 uint32_t dynamicOffsetCount,
5313 const uint32_t * pDynamicOffsets,
5314 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5315 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5316 // wrapper function for command vkCmdBindDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorSets.html
5317 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5318 void bindDescriptorSets( PipelineBindPoint pipelineBindPoint,
5319 PipelineLayout layout,
5320 uint32_t firstSet,
5321 ArrayProxy<const DescriptorSet> const & descriptorSets,
5322 ArrayProxy<const uint32_t> const & dynamicOffsets,
5323 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5324 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5325
5326 // wrapper function for command vkCmdClearColorImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdClearColorImage.html
5327 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5328 void clearColorImage( Image image,
5329 ImageLayout imageLayout,
5330 const ClearColorValue * pColor,
5331 uint32_t rangeCount,
5332 const ImageSubresourceRange * pRanges,
5333 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5334 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5335 // wrapper function for command vkCmdClearColorImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdClearColorImage.html
5336 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5337 void clearColorImage( Image image,
5338 ImageLayout imageLayout,
5339 const ClearColorValue & color,
5340 ArrayProxy<const ImageSubresourceRange> const & ranges,
5341 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5342 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5343
5344 // wrapper function for command vkCmdDispatch, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatch.html
5345 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5346 void dispatch( uint32_t groupCountX,
5347 uint32_t groupCountY,
5348 uint32_t groupCountZ,
5349 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5350
5351 // wrapper function for command vkCmdDispatchIndirect, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchIndirect.html
5352 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5353 void dispatchIndirect( Buffer buffer, DeviceSize offset, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5354
5355 // wrapper function for command vkCmdSetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetEvent.html
5356 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5357 void setEvent( Event event, PipelineStageFlags stageMask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5358
5359 // wrapper function for command vkCmdResetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResetEvent.html
5360 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5361 void resetEvent( Event event, PipelineStageFlags stageMask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5362
5363 // wrapper function for command vkCmdWaitEvents, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWaitEvents.html
5364 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5365 void waitEvents( uint32_t eventCount,
5366 const Event * pEvents,
5367 PipelineStageFlags srcStageMask,
5368 PipelineStageFlags dstStageMask,
5369 uint32_t memoryBarrierCount,
5370 const MemoryBarrier * pMemoryBarriers,
5371 uint32_t bufferMemoryBarrierCount,
5372 const BufferMemoryBarrier * pBufferMemoryBarriers,
5373 uint32_t imageMemoryBarrierCount,
5374 const ImageMemoryBarrier * pImageMemoryBarriers,
5375 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5376 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5377 // wrapper function for command vkCmdWaitEvents, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWaitEvents.html
5378 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5379 void waitEvents( ArrayProxy<const Event> const & events,
5380 PipelineStageFlags srcStageMask,
5381 PipelineStageFlags dstStageMask,
5382 ArrayProxy<const MemoryBarrier> const & memoryBarriers,
5383 ArrayProxy<const BufferMemoryBarrier> const & bufferMemoryBarriers,
5384 ArrayProxy<const ImageMemoryBarrier> const & imageMemoryBarriers,
5385 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5386 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5387
5388 // wrapper function for command vkCmdPushConstants, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushConstants.html
5389 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5390 void pushConstants( PipelineLayout layout,
5391 ShaderStageFlags stageFlags,
5392 uint32_t offset,
5393 uint32_t size,
5394 const void * pValues,
5395 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5396 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5397 // wrapper function for command vkCmdPushConstants, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushConstants.html
5398 template <typename ValuesType,
5399 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
5400 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5401 void pushConstants( PipelineLayout layout,
5402 ShaderStageFlags stageFlags,
5403 uint32_t offset,
5404 ArrayProxy<const ValuesType> const & values,
5405 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5406 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5407
5408 // wrapper function for command vkCmdSetViewport, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewport.html
5409 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5410 void setViewport( uint32_t firstViewport,
5411 uint32_t viewportCount,
5412 const Viewport * pViewports,
5413 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5414 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5415 // wrapper function for command vkCmdSetViewport, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewport.html
5416 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5417 void setViewport( uint32_t firstViewport,
5418 ArrayProxy<const Viewport> const & viewports,
5419 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5420 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5421
5422 // wrapper function for command vkCmdSetScissor, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetScissor.html
5423 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5424 void setScissor( uint32_t firstScissor,
5425 uint32_t scissorCount,
5426 const Rect2D * pScissors,
5427 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5428 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5429 // wrapper function for command vkCmdSetScissor, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetScissor.html
5430 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5431 void setScissor( uint32_t firstScissor,
5432 ArrayProxy<const Rect2D> const & scissors,
5433 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5434 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5435
5436 // wrapper function for command vkCmdSetLineWidth, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineWidth.html
5437 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5438 void setLineWidth( float lineWidth, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5439
5440 // wrapper function for command vkCmdSetDepthBias, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBias.html
5441 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5442 void setDepthBias( float depthBiasConstantFactor,
5443 float depthBiasClamp,
5444 float depthBiasSlopeFactor,
5445 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5446
5447 // wrapper function for command vkCmdSetBlendConstants, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetBlendConstants.html
5448 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5449 void setBlendConstants( const float blendConstants[4], Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5450
5451 // wrapper function for command vkCmdSetDepthBounds, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBounds.html
5452 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5453 void setDepthBounds( float minDepthBounds, float maxDepthBounds, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5454
5455 // wrapper function for command vkCmdSetStencilCompareMask, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilCompareMask.html
5456 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5457 void setStencilCompareMask( StencilFaceFlags faceMask,
5458 uint32_t compareMask,
5459 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5460
5461 // wrapper function for command vkCmdSetStencilWriteMask, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilWriteMask.html
5462 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5463 void setStencilWriteMask( StencilFaceFlags faceMask,
5464 uint32_t writeMask,
5465 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5466
5467 // wrapper function for command vkCmdSetStencilReference, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilReference.html
5468 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5469 void setStencilReference( StencilFaceFlags faceMask,
5470 uint32_t reference,
5471 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5472
5473 // wrapper function for command vkCmdBindIndexBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindIndexBuffer.html
5474 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5475 void bindIndexBuffer( Buffer buffer,
5476 DeviceSize offset,
5477 IndexType indexType,
5478 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5479
5480 // wrapper function for command vkCmdBindVertexBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers.html
5481 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5482 void bindVertexBuffers( uint32_t firstBinding,
5483 uint32_t bindingCount,
5484 const Buffer * pBuffers,
5485 const DeviceSize * pOffsets,
5486 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5487 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5488 // wrapper function for command vkCmdBindVertexBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers.html
5489 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5490 void bindVertexBuffers( uint32_t firstBinding,
5491 ArrayProxy<const Buffer> const & buffers,
5492 ArrayProxy<const DeviceSize> const & offsets,
5493 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
5494 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5495
5496 // wrapper function for command vkCmdDraw, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDraw.html
5497 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5498 void draw( uint32_t vertexCount,
5499 uint32_t instanceCount,
5500 uint32_t firstVertex,
5501 uint32_t firstInstance,
5502 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5503
5504 // wrapper function for command vkCmdDrawIndexed, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexed.html
5505 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5506 void drawIndexed( uint32_t indexCount,
5507 uint32_t instanceCount,
5508 uint32_t firstIndex,
5509 int32_t vertexOffset,
5510 uint32_t firstInstance,
5511 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5512
5513 // wrapper function for command vkCmdDrawIndirect, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirect.html
5514 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5515 void drawIndirect( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT )
5516 const VULKAN_HPP_NOEXCEPT;
5517
5518 // wrapper function for command vkCmdDrawIndexedIndirect, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexedIndirect.html
5519 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5520 void drawIndexedIndirect( Buffer buffer,
5521 DeviceSize offset,
5522 uint32_t drawCount,
5523 uint32_t stride,
5524 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5525
5526 // wrapper function for command vkCmdBlitImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBlitImage.html
5527 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5528 void blitImage( Image srcImage,
5529 ImageLayout srcImageLayout,
5530 Image dstImage,
5531 ImageLayout dstImageLayout,
5532 uint32_t regionCount,
5533 const ImageBlit * pRegions,
5534 Filter filter,
5535 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5536 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5537 // wrapper function for command vkCmdBlitImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBlitImage.html
5538 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5539 void blitImage( Image srcImage,
5540 ImageLayout srcImageLayout,
5541 Image dstImage,
5542 ImageLayout dstImageLayout,
5543 ArrayProxy<const ImageBlit> const & regions,
5544 Filter filter,
5545 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5546 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5547
5548 // wrapper function for command vkCmdClearDepthStencilImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdClearDepthStencilImage.html
5549 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5550 void clearDepthStencilImage( Image image,
5551 ImageLayout imageLayout,
5552 const ClearDepthStencilValue * pDepthStencil,
5553 uint32_t rangeCount,
5554 const ImageSubresourceRange * pRanges,
5555 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5556 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5557 // wrapper function for command vkCmdClearDepthStencilImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdClearDepthStencilImage.html
5558 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5559 void clearDepthStencilImage( Image image,
5560 ImageLayout imageLayout,
5561 const ClearDepthStencilValue & depthStencil,
5562 ArrayProxy<const ImageSubresourceRange> const & ranges,
5563 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5564 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5565
5566 // wrapper function for command vkCmdClearAttachments, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdClearAttachments.html
5567 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5568 void clearAttachments( uint32_t attachmentCount,
5569 const ClearAttachment * pAttachments,
5570 uint32_t rectCount,
5571 const ClearRect * pRects,
5572 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5573 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5574 // wrapper function for command vkCmdClearAttachments, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdClearAttachments.html
5575 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5576 void clearAttachments( ArrayProxy<const ClearAttachment> const & attachments,
5577 ArrayProxy<const ClearRect> const & rects,
5578 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5579 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5580
5581 // wrapper function for command vkCmdResolveImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResolveImage.html
5582 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5583 void resolveImage( Image srcImage,
5584 ImageLayout srcImageLayout,
5585 Image dstImage,
5586 ImageLayout dstImageLayout,
5587 uint32_t regionCount,
5588 const ImageResolve * pRegions,
5589 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5590 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5591 // wrapper function for command vkCmdResolveImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResolveImage.html
5592 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5593 void resolveImage( Image srcImage,
5594 ImageLayout srcImageLayout,
5595 Image dstImage,
5596 ImageLayout dstImageLayout,
5597 ArrayProxy<const ImageResolve> const & regions,
5598 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5599 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5600
5601 // wrapper function for command vkCmdBeginRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderPass.html
5602 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5603 void beginRenderPass( const RenderPassBeginInfo * pRenderPassBegin,
5604 SubpassContents contents,
5605 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5606 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5607 // wrapper function for command vkCmdBeginRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderPass.html
5608 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5609 void beginRenderPass( const RenderPassBeginInfo & renderPassBegin,
5610 SubpassContents contents,
5611 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5612 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5613
5614 // wrapper function for command vkCmdNextSubpass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdNextSubpass.html
5615 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5616 void nextSubpass( SubpassContents contents, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5617
5618 // wrapper function for command vkCmdEndRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderPass.html
5619 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5620 void endRenderPass( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5621
5622 //=== VK_VERSION_1_1 ===
5623
5624 // wrapper function for command vkCmdSetDeviceMask, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDeviceMask.html
5625 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5626 void setDeviceMask( uint32_t deviceMask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5627
5628 // wrapper function for command vkCmdDispatchBase, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchBase.html
5629 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5630 void dispatchBase( uint32_t baseGroupX,
5631 uint32_t baseGroupY,
5632 uint32_t baseGroupZ,
5633 uint32_t groupCountX,
5634 uint32_t groupCountY,
5635 uint32_t groupCountZ,
5636 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5637
5638 //=== VK_VERSION_1_2 ===
5639
5640 // wrapper function for command vkCmdDrawIndirectCount, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirectCount.html
5641 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5642 void drawIndirectCount( Buffer buffer,
5643 DeviceSize offset,
5644 Buffer countBuffer,
5645 DeviceSize countBufferOffset,
5646 uint32_t maxDrawCount,
5647 uint32_t stride,
5648 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5649
5650 // wrapper function for command vkCmdDrawIndexedIndirectCount, see
5651 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexedIndirectCount.html
5652 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5653 void drawIndexedIndirectCount( Buffer buffer,
5654 DeviceSize offset,
5655 Buffer countBuffer,
5656 DeviceSize countBufferOffset,
5657 uint32_t maxDrawCount,
5658 uint32_t stride,
5659 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5660
5661 // wrapper function for command vkCmdBeginRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderPass2.html
5662 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5663 void beginRenderPass2( const RenderPassBeginInfo * pRenderPassBegin,
5664 const SubpassBeginInfo * pSubpassBeginInfo,
5665 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5666 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5667 // wrapper function for command vkCmdBeginRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderPass2.html
5668 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5669 void beginRenderPass2( const RenderPassBeginInfo & renderPassBegin,
5670 const SubpassBeginInfo & subpassBeginInfo,
5671 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5672 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5673
5674 // wrapper function for command vkCmdNextSubpass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdNextSubpass2.html
5675 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5676 void nextSubpass2( const SubpassBeginInfo * pSubpassBeginInfo,
5677 const SubpassEndInfo * pSubpassEndInfo,
5678 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5679 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5680 // wrapper function for command vkCmdNextSubpass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdNextSubpass2.html
5681 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5682 void nextSubpass2( const SubpassBeginInfo & subpassBeginInfo,
5683 const SubpassEndInfo & subpassEndInfo,
5684 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5685 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5686
5687 // wrapper function for command vkCmdEndRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderPass2.html
5688 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5689 void endRenderPass2( const SubpassEndInfo * pSubpassEndInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5690 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5691 // wrapper function for command vkCmdEndRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderPass2.html
5692 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5693 void endRenderPass2( const SubpassEndInfo & subpassEndInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5694 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5695
5696 //=== VK_VERSION_1_3 ===
5697
5698 // wrapper function for command vkCmdPipelineBarrier2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPipelineBarrier2.html
5699 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5700 void pipelineBarrier2( const DependencyInfo * pDependencyInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5701 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5702 // wrapper function for command vkCmdPipelineBarrier2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPipelineBarrier2.html
5703 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5704 void pipelineBarrier2( const DependencyInfo & dependencyInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5705 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5706
5707 // wrapper function for command vkCmdWriteTimestamp2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteTimestamp2.html
5708 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5709 void writeTimestamp2( PipelineStageFlags2 stage,
5710 QueryPool queryPool,
5711 uint32_t query,
5712 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5713
5714 // wrapper function for command vkCmdCopyBuffer2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBuffer2.html
5715 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5716 void copyBuffer2( const CopyBufferInfo2 * pCopyBufferInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5717 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5718 // wrapper function for command vkCmdCopyBuffer2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBuffer2.html
5719 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5720 void copyBuffer2( const CopyBufferInfo2 & copyBufferInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5721 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5722
5723 // wrapper function for command vkCmdCopyImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImage2.html
5724 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5725 void copyImage2( const CopyImageInfo2 * pCopyImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5726 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5727 // wrapper function for command vkCmdCopyImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImage2.html
5728 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5729 void copyImage2( const CopyImageInfo2 & copyImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5730 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5731
5732 // wrapper function for command vkCmdCopyBufferToImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBufferToImage2.html
5733 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5734 void copyBufferToImage2( const CopyBufferToImageInfo2 * pCopyBufferToImageInfo,
5735 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5736 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5737 // wrapper function for command vkCmdCopyBufferToImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBufferToImage2.html
5738 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5739 void copyBufferToImage2( const CopyBufferToImageInfo2 & copyBufferToImageInfo,
5740 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5741 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5742
5743 // wrapper function for command vkCmdCopyImageToBuffer2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToBuffer2.html
5744 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5745 void copyImageToBuffer2( const CopyImageToBufferInfo2 * pCopyImageToBufferInfo,
5746 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5747 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5748 // wrapper function for command vkCmdCopyImageToBuffer2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToBuffer2.html
5749 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5750 void copyImageToBuffer2( const CopyImageToBufferInfo2 & copyImageToBufferInfo,
5751 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5752 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5753
5754 // wrapper function for command vkCmdSetEvent2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetEvent2.html
5755 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5756 void
5757 setEvent2( Event event, const DependencyInfo * pDependencyInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5758 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5759 // wrapper function for command vkCmdSetEvent2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetEvent2.html
5760 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5761 void setEvent2( Event event, const DependencyInfo & dependencyInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5762 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5763
5764 // wrapper function for command vkCmdResetEvent2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResetEvent2.html
5765 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5766 void resetEvent2( Event event, PipelineStageFlags2 stageMask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5767
5768 // wrapper function for command vkCmdWaitEvents2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWaitEvents2.html
5769 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5770 void waitEvents2( uint32_t eventCount,
5771 const Event * pEvents,
5772 const DependencyInfo * pDependencyInfos,
5773 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5774 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5775 // wrapper function for command vkCmdWaitEvents2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWaitEvents2.html
5776 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5777 void waitEvents2( ArrayProxy<const Event> const & events,
5778 ArrayProxy<const DependencyInfo> const & dependencyInfos,
5779 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
5780 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5781
5782 // wrapper function for command vkCmdBlitImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBlitImage2.html
5783 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5784 void blitImage2( const BlitImageInfo2 * pBlitImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5785 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5786 // wrapper function for command vkCmdBlitImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBlitImage2.html
5787 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5788 void blitImage2( const BlitImageInfo2 & blitImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5789 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5790
5791 // wrapper function for command vkCmdResolveImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResolveImage2.html
5792 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5793 void resolveImage2( const ResolveImageInfo2 * pResolveImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5794 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5795 // wrapper function for command vkCmdResolveImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResolveImage2.html
5796 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5797 void resolveImage2( const ResolveImageInfo2 & resolveImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5798 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5799
5800 // wrapper function for command vkCmdBeginRendering, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRendering.html
5801 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5802 void beginRendering( const RenderingInfo * pRenderingInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5803 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5804 // wrapper function for command vkCmdBeginRendering, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRendering.html
5805 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5806 void beginRendering( const RenderingInfo & renderingInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5807 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5808
5809 // wrapper function for command vkCmdEndRendering, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering.html
5810 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5811 void endRendering( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5812
5813 // wrapper function for command vkCmdSetCullMode, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCullMode.html
5814 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5815 void setCullMode( CullModeFlags cullMode, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5816
5817 // wrapper function for command vkCmdSetFrontFace, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFrontFace.html
5818 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5819 void setFrontFace( FrontFace frontFace, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5820
5821 // wrapper function for command vkCmdSetPrimitiveTopology, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPrimitiveTopology.html
5822 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5823 void setPrimitiveTopology( PrimitiveTopology primitiveTopology, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5824
5825 // wrapper function for command vkCmdSetViewportWithCount, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWithCount.html
5826 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5827 void setViewportWithCount( uint32_t viewportCount,
5828 const Viewport * pViewports,
5829 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5830 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5831 // wrapper function for command vkCmdSetViewportWithCount, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWithCount.html
5832 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5833 void setViewportWithCount( ArrayProxy<const Viewport> const & viewports,
5834 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5835 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5836
5837 // wrapper function for command vkCmdSetScissorWithCount, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetScissorWithCount.html
5838 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5839 void setScissorWithCount( uint32_t scissorCount,
5840 const Rect2D * pScissors,
5841 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5842 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5843 // wrapper function for command vkCmdSetScissorWithCount, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetScissorWithCount.html
5844 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5845 void setScissorWithCount( ArrayProxy<const Rect2D> const & scissors,
5846 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5847 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5848
5849 // wrapper function for command vkCmdBindVertexBuffers2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers2.html
5850 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5851 void bindVertexBuffers2( uint32_t firstBinding,
5852 uint32_t bindingCount,
5853 const Buffer * pBuffers,
5854 const DeviceSize * pOffsets,
5855 const DeviceSize * pSizes,
5856 const DeviceSize * pStrides,
5857 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5858 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5859 // wrapper function for command vkCmdBindVertexBuffers2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers2.html
5860 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5861 void bindVertexBuffers2( uint32_t firstBinding,
5862 ArrayProxy<const Buffer> const & buffers,
5863 ArrayProxy<const DeviceSize> const & offsets,
5864 ArrayProxy<const DeviceSize> const & sizes VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
5865 ArrayProxy<const DeviceSize> const & strides VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
5866 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
5867 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5868
5869 // wrapper function for command vkCmdSetDepthTestEnable, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthTestEnable.html
5870 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5871 void setDepthTestEnable( Bool32 depthTestEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5872
5873 // wrapper function for command vkCmdSetDepthWriteEnable, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthWriteEnable.html
5874 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5875 void setDepthWriteEnable( Bool32 depthWriteEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5876
5877 // wrapper function for command vkCmdSetDepthCompareOp, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthCompareOp.html
5878 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5879 void setDepthCompareOp( CompareOp depthCompareOp, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5880
5881 // wrapper function for command vkCmdSetDepthBoundsTestEnable, see
5882 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBoundsTestEnable.html
5883 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5884 void setDepthBoundsTestEnable( Bool32 depthBoundsTestEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5885
5886 // wrapper function for command vkCmdSetStencilTestEnable, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilTestEnable.html
5887 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5888 void setStencilTestEnable( Bool32 stencilTestEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5889
5890 // wrapper function for command vkCmdSetStencilOp, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilOp.html
5891 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5892 void setStencilOp( StencilFaceFlags faceMask,
5893 StencilOp failOp,
5894 StencilOp passOp,
5895 StencilOp depthFailOp,
5896 CompareOp compareOp,
5897 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5898
5899 // wrapper function for command vkCmdSetRasterizerDiscardEnable, see
5900 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRasterizerDiscardEnable.html
5901 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5902 void setRasterizerDiscardEnable( Bool32 rasterizerDiscardEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5903
5904 // wrapper function for command vkCmdSetDepthBiasEnable, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBiasEnable.html
5905 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5906 void setDepthBiasEnable( Bool32 depthBiasEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5907
5908 // wrapper function for command vkCmdSetPrimitiveRestartEnable, see
5909 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPrimitiveRestartEnable.html
5910 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5911 void setPrimitiveRestartEnable( Bool32 primitiveRestartEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5912
5913 //=== VK_VERSION_1_4 ===
5914
5915 // wrapper function for command vkCmdPushDescriptorSet, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSet.html
5916 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5917 void pushDescriptorSet( PipelineBindPoint pipelineBindPoint,
5918 PipelineLayout layout,
5919 uint32_t set,
5920 uint32_t descriptorWriteCount,
5921 const WriteDescriptorSet * pDescriptorWrites,
5922 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5923 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5924 // wrapper function for command vkCmdPushDescriptorSet, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSet.html
5925 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5926 void pushDescriptorSet( PipelineBindPoint pipelineBindPoint,
5927 PipelineLayout layout,
5928 uint32_t set,
5929 ArrayProxy<const WriteDescriptorSet> const & descriptorWrites,
5930 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5931 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5932
5933 // wrapper function for command vkCmdPushDescriptorSetWithTemplate, see
5934 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplate.html
5935 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5936 void pushDescriptorSetWithTemplate( DescriptorUpdateTemplate descriptorUpdateTemplate,
5937 PipelineLayout layout,
5938 uint32_t set,
5939 const void * pData,
5940 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5941 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5942 // wrapper function for command vkCmdPushDescriptorSetWithTemplate, see
5943 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplate.html
5944 template <typename DataType,
5945 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
5946 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5947 void pushDescriptorSetWithTemplate( DescriptorUpdateTemplate descriptorUpdateTemplate,
5948 PipelineLayout layout,
5949 uint32_t set,
5950 DataType const & data,
5951 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5952 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5953
5954 // wrapper function for command vkCmdBindDescriptorSets2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorSets2.html
5955 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5956 void bindDescriptorSets2( const BindDescriptorSetsInfo * pBindDescriptorSetsInfo,
5957 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5958 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5959 // wrapper function for command vkCmdBindDescriptorSets2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorSets2.html
5960 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5961 void bindDescriptorSets2( const BindDescriptorSetsInfo & bindDescriptorSetsInfo,
5962 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5963 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5964
5965 // wrapper function for command vkCmdPushConstants2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushConstants2.html
5966 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5967 void pushConstants2( const PushConstantsInfo * pPushConstantsInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5968 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5969 // wrapper function for command vkCmdPushConstants2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushConstants2.html
5970 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5971 void pushConstants2( const PushConstantsInfo & pushConstantsInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5972 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5973
5974 // wrapper function for command vkCmdPushDescriptorSet2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSet2.html
5975 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5976 void pushDescriptorSet2( const PushDescriptorSetInfo * pPushDescriptorSetInfo,
5977 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5978 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5979 // wrapper function for command vkCmdPushDescriptorSet2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSet2.html
5980 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5981 void pushDescriptorSet2( const PushDescriptorSetInfo & pushDescriptorSetInfo,
5982 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5983 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5984
5985 // wrapper function for command vkCmdPushDescriptorSetWithTemplate2, see
5986 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplate2.html
5987 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5988 void pushDescriptorSetWithTemplate2( const PushDescriptorSetWithTemplateInfo * pPushDescriptorSetWithTemplateInfo,
5989 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5990 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5991 // wrapper function for command vkCmdPushDescriptorSetWithTemplate2, see
5992 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplate2.html
5993 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
5994 void pushDescriptorSetWithTemplate2( const PushDescriptorSetWithTemplateInfo & pushDescriptorSetWithTemplateInfo,
5995 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5996 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5997
5998 // wrapper function for command vkCmdSetLineStipple, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineStipple.html
5999 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6000 void setLineStipple( uint32_t lineStippleFactor,
6001 uint16_t lineStipplePattern,
6002 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6003
6004 // wrapper function for command vkCmdBindIndexBuffer2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindIndexBuffer2.html
6005 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6006 void bindIndexBuffer2( Buffer buffer, DeviceSize offset, DeviceSize size, IndexType indexType, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT )
6007 const VULKAN_HPP_NOEXCEPT;
6008
6009 // wrapper function for command vkCmdSetRenderingAttachmentLocations, see
6010 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingAttachmentLocations.html
6011 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6012 void setRenderingAttachmentLocations( const RenderingAttachmentLocationInfo * pLocationInfo,
6013 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6014 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6015 // wrapper function for command vkCmdSetRenderingAttachmentLocations, see
6016 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingAttachmentLocations.html
6017 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6018 void setRenderingAttachmentLocations( const RenderingAttachmentLocationInfo & locationInfo,
6019 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6020 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6021
6022 // wrapper function for command vkCmdSetRenderingInputAttachmentIndices, see
6023 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingInputAttachmentIndices.html
6024 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6025 void setRenderingInputAttachmentIndices( const RenderingInputAttachmentIndexInfo * pInputAttachmentIndexInfo,
6026 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6027 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6028 // wrapper function for command vkCmdSetRenderingInputAttachmentIndices, see
6029 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingInputAttachmentIndices.html
6030 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6031 void setRenderingInputAttachmentIndices( const RenderingInputAttachmentIndexInfo & inputAttachmentIndexInfo,
6032 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6033 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6034
6035 //=== VK_EXT_debug_marker ===
6036
6037 // wrapper function for command vkCmdDebugMarkerBeginEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDebugMarkerBeginEXT.html
6038 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6039 void debugMarkerBeginEXT( const DebugMarkerMarkerInfoEXT * pMarkerInfo,
6040 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6041 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6042 // wrapper function for command vkCmdDebugMarkerBeginEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDebugMarkerBeginEXT.html
6043 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6044 void debugMarkerBeginEXT( const DebugMarkerMarkerInfoEXT & markerInfo,
6045 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6046 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6047
6048 // wrapper function for command vkCmdDebugMarkerEndEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDebugMarkerEndEXT.html
6049 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6050 void debugMarkerEndEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6051
6052 // wrapper function for command vkCmdDebugMarkerInsertEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDebugMarkerInsertEXT.html
6053 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6054 void debugMarkerInsertEXT( const DebugMarkerMarkerInfoEXT * pMarkerInfo,
6055 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6056 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6057 // wrapper function for command vkCmdDebugMarkerInsertEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDebugMarkerInsertEXT.html
6058 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6059 void debugMarkerInsertEXT( const DebugMarkerMarkerInfoEXT & markerInfo,
6060 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6061 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6062
6063 //=== VK_KHR_video_queue ===
6064
6065 // wrapper function for command vkCmdBeginVideoCodingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginVideoCodingKHR.html
6066 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6067 void beginVideoCodingKHR( const VideoBeginCodingInfoKHR * pBeginInfo,
6068 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6069 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6070 // wrapper function for command vkCmdBeginVideoCodingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginVideoCodingKHR.html
6071 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6072 void beginVideoCodingKHR( const VideoBeginCodingInfoKHR & beginInfo,
6073 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6074 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6075
6076 // wrapper function for command vkCmdEndVideoCodingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndVideoCodingKHR.html
6077 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6078 void endVideoCodingKHR( const VideoEndCodingInfoKHR * pEndCodingInfo,
6079 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6080 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6081 // wrapper function for command vkCmdEndVideoCodingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndVideoCodingKHR.html
6082 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6083 void endVideoCodingKHR( const VideoEndCodingInfoKHR & endCodingInfo,
6084 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6085 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6086
6087 // wrapper function for command vkCmdControlVideoCodingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdControlVideoCodingKHR.html
6088 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6089 void controlVideoCodingKHR( const VideoCodingControlInfoKHR * pCodingControlInfo,
6090 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6091 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6092 // wrapper function for command vkCmdControlVideoCodingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdControlVideoCodingKHR.html
6093 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6094 void controlVideoCodingKHR( const VideoCodingControlInfoKHR & codingControlInfo,
6095 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6096 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6097
6098 //=== VK_KHR_video_decode_queue ===
6099
6100 // wrapper function for command vkCmdDecodeVideoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecodeVideoKHR.html
6101 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6102 void decodeVideoKHR( const VideoDecodeInfoKHR * pDecodeInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6103 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6104 // wrapper function for command vkCmdDecodeVideoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecodeVideoKHR.html
6105 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6106 void decodeVideoKHR( const VideoDecodeInfoKHR & decodeInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6107 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6108
6109 //=== VK_EXT_transform_feedback ===
6110
6111 // wrapper function for command vkCmdBindTransformFeedbackBuffersEXT, see
6112 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindTransformFeedbackBuffersEXT.html
6113 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6114 void bindTransformFeedbackBuffersEXT( uint32_t firstBinding,
6115 uint32_t bindingCount,
6116 const Buffer * pBuffers,
6117 const DeviceSize * pOffsets,
6118 const DeviceSize * pSizes,
6119 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6120 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6121 // wrapper function for command vkCmdBindTransformFeedbackBuffersEXT, see
6122 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindTransformFeedbackBuffersEXT.html
6123 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6124 void bindTransformFeedbackBuffersEXT( uint32_t firstBinding,
6125 ArrayProxy<const Buffer> const & buffers,
6126 ArrayProxy<const DeviceSize> const & offsets,
6127 ArrayProxy<const DeviceSize> const & sizes VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
6128 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
6129 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6130
6131 // wrapper function for command vkCmdBeginTransformFeedbackEXT, see
6132 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginTransformFeedbackEXT.html
6133 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6134 void beginTransformFeedbackEXT( uint32_t firstCounterBuffer,
6135 uint32_t counterBufferCount,
6136 const Buffer * pCounterBuffers,
6137 const DeviceSize * pCounterBufferOffsets,
6138 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6139 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6140 // wrapper function for command vkCmdBeginTransformFeedbackEXT, see
6141 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginTransformFeedbackEXT.html
6142 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6143 void beginTransformFeedbackEXT( uint32_t firstCounterBuffer,
6144 ArrayProxy<const Buffer> const & counterBuffers,
6145 ArrayProxy<const DeviceSize> const & counterBufferOffsets VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
6146 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
6147 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6148
6149 // wrapper function for command vkCmdEndTransformFeedbackEXT, see
6150 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndTransformFeedbackEXT.html
6151 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6152 void endTransformFeedbackEXT( uint32_t firstCounterBuffer,
6153 uint32_t counterBufferCount,
6154 const Buffer * pCounterBuffers,
6155 const DeviceSize * pCounterBufferOffsets,
6156 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6157 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6158 // wrapper function for command vkCmdEndTransformFeedbackEXT, see
6159 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndTransformFeedbackEXT.html
6160 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6161 void endTransformFeedbackEXT( uint32_t firstCounterBuffer,
6162 ArrayProxy<const Buffer> const & counterBuffers,
6163 ArrayProxy<const DeviceSize> const & counterBufferOffsets VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
6164 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
6165 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6166
6167 // wrapper function for command vkCmdBeginQueryIndexedEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginQueryIndexedEXT.html
6168 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6169 void beginQueryIndexedEXT( QueryPool queryPool,
6170 uint32_t query,
6171 QueryControlFlags flags,
6172 uint32_t index,
6173 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6174
6175 // wrapper function for command vkCmdEndQueryIndexedEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndQueryIndexedEXT.html
6176 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6177 void endQueryIndexedEXT( QueryPool queryPool,
6178 uint32_t query,
6179 uint32_t index,
6180 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6181
6182 // wrapper function for command vkCmdDrawIndirectByteCountEXT, see
6183 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirectByteCountEXT.html
6184 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6185 void drawIndirectByteCountEXT( uint32_t instanceCount,
6186 uint32_t firstInstance,
6187 Buffer counterBuffer,
6188 DeviceSize counterBufferOffset,
6189 uint32_t counterOffset,
6190 uint32_t vertexStride,
6191 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6192
6193 //=== VK_NVX_binary_import ===
6194
6195 // wrapper function for command vkCmdCuLaunchKernelNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCuLaunchKernelNVX.html
6196 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6197 void cuLaunchKernelNVX( const CuLaunchInfoNVX * pLaunchInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6198 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6199 // wrapper function for command vkCmdCuLaunchKernelNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCuLaunchKernelNVX.html
6200 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6201 void cuLaunchKernelNVX( const CuLaunchInfoNVX & launchInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6202 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6203
6204 //=== VK_AMD_draw_indirect_count ===
6205
6206 // wrapper function for command vkCmdDrawIndirectCountAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirectCountAMD.html
6207 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6208 void drawIndirectCountAMD( Buffer buffer,
6209 DeviceSize offset,
6210 Buffer countBuffer,
6211 DeviceSize countBufferOffset,
6212 uint32_t maxDrawCount,
6213 uint32_t stride,
6214 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6215
6216 // wrapper function for command vkCmdDrawIndexedIndirectCountAMD, see
6217 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexedIndirectCountAMD.html
6218 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6219 void drawIndexedIndirectCountAMD( Buffer buffer,
6220 DeviceSize offset,
6221 Buffer countBuffer,
6222 DeviceSize countBufferOffset,
6223 uint32_t maxDrawCount,
6224 uint32_t stride,
6225 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6226
6227 //=== VK_KHR_dynamic_rendering ===
6228
6229 // wrapper function for command vkCmdBeginRenderingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderingKHR.html
6230 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6231 void beginRenderingKHR( const RenderingInfo * pRenderingInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6232 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6233 // wrapper function for command vkCmdBeginRenderingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderingKHR.html
6234 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6235 void beginRenderingKHR( const RenderingInfo & renderingInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6236 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6237
6238 // wrapper function for command vkCmdEndRenderingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderingKHR.html
6239 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6240 void endRenderingKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6241
6242 //=== VK_KHR_device_group ===
6243
6244 // wrapper function for command vkCmdSetDeviceMaskKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDeviceMaskKHR.html
6245 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6246 void setDeviceMaskKHR( uint32_t deviceMask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6247
6248 // wrapper function for command vkCmdDispatchBaseKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchBaseKHR.html
6249 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6250 void dispatchBaseKHR( uint32_t baseGroupX,
6251 uint32_t baseGroupY,
6252 uint32_t baseGroupZ,
6253 uint32_t groupCountX,
6254 uint32_t groupCountY,
6255 uint32_t groupCountZ,
6256 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6257
6258 //=== VK_KHR_push_descriptor ===
6259
6260 // wrapper function for command vkCmdPushDescriptorSetKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetKHR.html
6261 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6262 void pushDescriptorSetKHR( PipelineBindPoint pipelineBindPoint,
6263 PipelineLayout layout,
6264 uint32_t set,
6265 uint32_t descriptorWriteCount,
6266 const WriteDescriptorSet * pDescriptorWrites,
6267 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6268 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6269 // wrapper function for command vkCmdPushDescriptorSetKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetKHR.html
6270 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6271 void pushDescriptorSetKHR( PipelineBindPoint pipelineBindPoint,
6272 PipelineLayout layout,
6273 uint32_t set,
6274 ArrayProxy<const WriteDescriptorSet> const & descriptorWrites,
6275 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6276 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6277
6278 // wrapper function for command vkCmdPushDescriptorSetWithTemplateKHR, see
6279 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplateKHR.html
6280 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6281 void pushDescriptorSetWithTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate,
6282 PipelineLayout layout,
6283 uint32_t set,
6284 const void * pData,
6285 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6286 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6287 // wrapper function for command vkCmdPushDescriptorSetWithTemplateKHR, see
6288 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplateKHR.html
6289 template <typename DataType,
6290 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
6291 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6292 void pushDescriptorSetWithTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate,
6293 PipelineLayout layout,
6294 uint32_t set,
6295 DataType const & data,
6296 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6297 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6298
6299 //=== VK_EXT_conditional_rendering ===
6300
6301 // wrapper function for command vkCmdBeginConditionalRenderingEXT, see
6302 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginConditionalRenderingEXT.html
6303 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6304 void beginConditionalRenderingEXT( const ConditionalRenderingBeginInfoEXT * pConditionalRenderingBegin,
6305 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6306 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6307 // wrapper function for command vkCmdBeginConditionalRenderingEXT, see
6308 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginConditionalRenderingEXT.html
6309 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6310 void beginConditionalRenderingEXT( const ConditionalRenderingBeginInfoEXT & conditionalRenderingBegin,
6311 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6312 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6313
6314 // wrapper function for command vkCmdEndConditionalRenderingEXT, see
6315 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndConditionalRenderingEXT.html
6316 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6317 void endConditionalRenderingEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6318
6319 //=== VK_NV_clip_space_w_scaling ===
6320
6321 // wrapper function for command vkCmdSetViewportWScalingNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWScalingNV.html
6322 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6323 void setViewportWScalingNV( uint32_t firstViewport,
6324 uint32_t viewportCount,
6325 const ViewportWScalingNV * pViewportWScalings,
6326 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6327 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6328 // wrapper function for command vkCmdSetViewportWScalingNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWScalingNV.html
6329 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6330 void setViewportWScalingNV( uint32_t firstViewport,
6331 ArrayProxy<const ViewportWScalingNV> const & viewportWScalings,
6332 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6333 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6334
6335 //=== VK_EXT_discard_rectangles ===
6336
6337 // wrapper function for command vkCmdSetDiscardRectangleEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDiscardRectangleEXT.html
6338 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6339 void setDiscardRectangleEXT( uint32_t firstDiscardRectangle,
6340 uint32_t discardRectangleCount,
6341 const Rect2D * pDiscardRectangles,
6342 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6343 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6344 // wrapper function for command vkCmdSetDiscardRectangleEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDiscardRectangleEXT.html
6345 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6346 void setDiscardRectangleEXT( uint32_t firstDiscardRectangle,
6347 ArrayProxy<const Rect2D> const & discardRectangles,
6348 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6349 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6350
6351 // wrapper function for command vkCmdSetDiscardRectangleEnableEXT, see
6352 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDiscardRectangleEnableEXT.html
6353 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6354 void setDiscardRectangleEnableEXT( Bool32 discardRectangleEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6355
6356 // wrapper function for command vkCmdSetDiscardRectangleModeEXT, see
6357 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDiscardRectangleModeEXT.html
6358 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6359 void setDiscardRectangleModeEXT( DiscardRectangleModeEXT discardRectangleMode,
6360 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6361
6362 //=== VK_KHR_create_renderpass2 ===
6363
6364 // wrapper function for command vkCmdBeginRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderPass2KHR.html
6365 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6366 void beginRenderPass2KHR( const RenderPassBeginInfo * pRenderPassBegin,
6367 const SubpassBeginInfo * pSubpassBeginInfo,
6368 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6369 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6370 // wrapper function for command vkCmdBeginRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderPass2KHR.html
6371 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6372 void beginRenderPass2KHR( const RenderPassBeginInfo & renderPassBegin,
6373 const SubpassBeginInfo & subpassBeginInfo,
6374 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6375 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6376
6377 // wrapper function for command vkCmdNextSubpass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdNextSubpass2KHR.html
6378 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6379 void nextSubpass2KHR( const SubpassBeginInfo * pSubpassBeginInfo,
6380 const SubpassEndInfo * pSubpassEndInfo,
6381 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6382 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6383 // wrapper function for command vkCmdNextSubpass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdNextSubpass2KHR.html
6384 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6385 void nextSubpass2KHR( const SubpassBeginInfo & subpassBeginInfo,
6386 const SubpassEndInfo & subpassEndInfo,
6387 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6388 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6389
6390 // wrapper function for command vkCmdEndRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderPass2KHR.html
6391 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6392 void endRenderPass2KHR( const SubpassEndInfo * pSubpassEndInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6393 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6394 // wrapper function for command vkCmdEndRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderPass2KHR.html
6395 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6396 void endRenderPass2KHR( const SubpassEndInfo & subpassEndInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6397 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6398
6399 //=== VK_EXT_debug_utils ===
6400
6401 // wrapper function for command vkCmdBeginDebugUtilsLabelEXT, see
6402 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginDebugUtilsLabelEXT.html
6403 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6404 void beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT * pLabelInfo,
6405 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6406 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6407 // wrapper function for command vkCmdBeginDebugUtilsLabelEXT, see
6408 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginDebugUtilsLabelEXT.html
6409 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6410 void beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6411 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6412
6413 // wrapper function for command vkCmdEndDebugUtilsLabelEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndDebugUtilsLabelEXT.html
6414 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6415 void endDebugUtilsLabelEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6416
6417 // wrapper function for command vkCmdInsertDebugUtilsLabelEXT, see
6418 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdInsertDebugUtilsLabelEXT.html
6419 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6420 void insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT * pLabelInfo,
6421 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6422 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6423 // wrapper function for command vkCmdInsertDebugUtilsLabelEXT, see
6424 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdInsertDebugUtilsLabelEXT.html
6425 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6426 void insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo,
6427 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6428 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6429
6430 #if defined( VK_ENABLE_BETA_EXTENSIONS )
6431 //=== VK_AMDX_shader_enqueue ===
6432
6433 // wrapper function for command vkCmdInitializeGraphScratchMemoryAMDX, see
6434 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdInitializeGraphScratchMemoryAMDX.html
6435 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6436 void initializeGraphScratchMemoryAMDX( Pipeline executionGraph,
6437 DeviceAddress scratch,
6438 DeviceSize scratchSize,
6439 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6440
6441 // wrapper function for command vkCmdDispatchGraphAMDX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchGraphAMDX.html
6442 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6443 void dispatchGraphAMDX( DeviceAddress scratch,
6444 DeviceSize scratchSize,
6445 const DispatchGraphCountInfoAMDX * pCountInfo,
6446 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6447 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6448 // wrapper function for command vkCmdDispatchGraphAMDX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchGraphAMDX.html
6449 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6450 void dispatchGraphAMDX( DeviceAddress scratch,
6451 DeviceSize scratchSize,
6452 const DispatchGraphCountInfoAMDX & countInfo,
6453 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6454 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6455
6456 // wrapper function for command vkCmdDispatchGraphIndirectAMDX, see
6457 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchGraphIndirectAMDX.html
6458 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6459 void dispatchGraphIndirectAMDX( DeviceAddress scratch,
6460 DeviceSize scratchSize,
6461 const DispatchGraphCountInfoAMDX * pCountInfo,
6462 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6463 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6464 // wrapper function for command vkCmdDispatchGraphIndirectAMDX, see
6465 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchGraphIndirectAMDX.html
6466 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6467 void dispatchGraphIndirectAMDX( DeviceAddress scratch,
6468 DeviceSize scratchSize,
6469 const DispatchGraphCountInfoAMDX & countInfo,
6470 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6471 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6472
6473 // wrapper function for command vkCmdDispatchGraphIndirectCountAMDX, see
6474 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchGraphIndirectCountAMDX.html
6475 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6476 void dispatchGraphIndirectCountAMDX( DeviceAddress scratch,
6477 DeviceSize scratchSize,
6478 DeviceAddress countInfo,
6479 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6480 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
6481
6482 //=== VK_EXT_sample_locations ===
6483
6484 // wrapper function for command vkCmdSetSampleLocationsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetSampleLocationsEXT.html
6485 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6486 void setSampleLocationsEXT( const SampleLocationsInfoEXT * pSampleLocationsInfo,
6487 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6488 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6489 // wrapper function for command vkCmdSetSampleLocationsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetSampleLocationsEXT.html
6490 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6491 void setSampleLocationsEXT( const SampleLocationsInfoEXT & sampleLocationsInfo,
6492 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6493 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6494
6495 //=== VK_KHR_acceleration_structure ===
6496
6497 // wrapper function for command vkCmdBuildAccelerationStructuresKHR, see
6498 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildAccelerationStructuresKHR.html
6499 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6500 void buildAccelerationStructuresKHR( uint32_t infoCount,
6501 const AccelerationStructureBuildGeometryInfoKHR * pInfos,
6502 const AccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos,
6503 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6504 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6505 // wrapper function for command vkCmdBuildAccelerationStructuresKHR, see
6506 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildAccelerationStructuresKHR.html
6507 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6508 void buildAccelerationStructuresKHR( ArrayProxy<const AccelerationStructureBuildGeometryInfoKHR> const & infos,
6509 ArrayProxy<const AccelerationStructureBuildRangeInfoKHR * const> const & pBuildRangeInfos,
6510 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
6511 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6512
6513 // wrapper function for command vkCmdBuildAccelerationStructuresIndirectKHR, see
6514 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildAccelerationStructuresIndirectKHR.html
6515 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6516 void buildAccelerationStructuresIndirectKHR( uint32_t infoCount,
6517 const AccelerationStructureBuildGeometryInfoKHR * pInfos,
6518 const DeviceAddress * pIndirectDeviceAddresses,
6519 const uint32_t * pIndirectStrides,
6520 const uint32_t * const * ppMaxPrimitiveCounts,
6521 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6522 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6523 // wrapper function for command vkCmdBuildAccelerationStructuresIndirectKHR, see
6524 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildAccelerationStructuresIndirectKHR.html
6525 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6526 void buildAccelerationStructuresIndirectKHR( ArrayProxy<const AccelerationStructureBuildGeometryInfoKHR> const & infos,
6527 ArrayProxy<const DeviceAddress> const & indirectDeviceAddresses,
6528 ArrayProxy<const uint32_t> const & indirectStrides,
6529 ArrayProxy<const uint32_t * const> const & pMaxPrimitiveCounts,
6530 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
6531 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6532
6533 // wrapper function for command vkCmdCopyAccelerationStructureKHR, see
6534 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyAccelerationStructureKHR.html
6535 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6536 void copyAccelerationStructureKHR( const CopyAccelerationStructureInfoKHR * pInfo,
6537 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6538 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6539 // wrapper function for command vkCmdCopyAccelerationStructureKHR, see
6540 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyAccelerationStructureKHR.html
6541 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6542 void copyAccelerationStructureKHR( const CopyAccelerationStructureInfoKHR & info,
6543 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6544 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6545
6546 // wrapper function for command vkCmdCopyAccelerationStructureToMemoryKHR, see
6547 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyAccelerationStructureToMemoryKHR.html
6548 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6549 void copyAccelerationStructureToMemoryKHR( const CopyAccelerationStructureToMemoryInfoKHR * pInfo,
6550 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6551 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6552 // wrapper function for command vkCmdCopyAccelerationStructureToMemoryKHR, see
6553 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyAccelerationStructureToMemoryKHR.html
6554 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6555 void copyAccelerationStructureToMemoryKHR( const CopyAccelerationStructureToMemoryInfoKHR & info,
6556 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6557 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6558
6559 // wrapper function for command vkCmdCopyMemoryToAccelerationStructureKHR, see
6560 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToAccelerationStructureKHR.html
6561 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6562 void copyMemoryToAccelerationStructureKHR( const CopyMemoryToAccelerationStructureInfoKHR * pInfo,
6563 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6564 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6565 // wrapper function for command vkCmdCopyMemoryToAccelerationStructureKHR, see
6566 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToAccelerationStructureKHR.html
6567 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6568 void copyMemoryToAccelerationStructureKHR( const CopyMemoryToAccelerationStructureInfoKHR & info,
6569 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6570 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6571
6572 // wrapper function for command vkCmdWriteAccelerationStructuresPropertiesKHR, see
6573 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteAccelerationStructuresPropertiesKHR.html
6574 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6575 void writeAccelerationStructuresPropertiesKHR( uint32_t accelerationStructureCount,
6576 const AccelerationStructureKHR * pAccelerationStructures,
6577 QueryType queryType,
6578 QueryPool queryPool,
6579 uint32_t firstQuery,
6580 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6581 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6582 // wrapper function for command vkCmdWriteAccelerationStructuresPropertiesKHR, see
6583 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteAccelerationStructuresPropertiesKHR.html
6584 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6585 void writeAccelerationStructuresPropertiesKHR( ArrayProxy<const AccelerationStructureKHR> const & accelerationStructures,
6586 QueryType queryType,
6587 QueryPool queryPool,
6588 uint32_t firstQuery,
6589 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6590 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6591
6592 //=== VK_KHR_ray_tracing_pipeline ===
6593
6594 // wrapper function for command vkCmdTraceRaysKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdTraceRaysKHR.html
6595 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6596 void traceRaysKHR( const StridedDeviceAddressRegionKHR * pRaygenShaderBindingTable,
6597 const StridedDeviceAddressRegionKHR * pMissShaderBindingTable,
6598 const StridedDeviceAddressRegionKHR * pHitShaderBindingTable,
6599 const StridedDeviceAddressRegionKHR * pCallableShaderBindingTable,
6600 uint32_t width,
6601 uint32_t height,
6602 uint32_t depth,
6603 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6604 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6605 // wrapper function for command vkCmdTraceRaysKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdTraceRaysKHR.html
6606 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6607 void traceRaysKHR( const StridedDeviceAddressRegionKHR & raygenShaderBindingTable,
6608 const StridedDeviceAddressRegionKHR & missShaderBindingTable,
6609 const StridedDeviceAddressRegionKHR & hitShaderBindingTable,
6610 const StridedDeviceAddressRegionKHR & callableShaderBindingTable,
6611 uint32_t width,
6612 uint32_t height,
6613 uint32_t depth,
6614 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6615 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6616
6617 // wrapper function for command vkCmdTraceRaysIndirectKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdTraceRaysIndirectKHR.html
6618 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6619 void traceRaysIndirectKHR( const StridedDeviceAddressRegionKHR * pRaygenShaderBindingTable,
6620 const StridedDeviceAddressRegionKHR * pMissShaderBindingTable,
6621 const StridedDeviceAddressRegionKHR * pHitShaderBindingTable,
6622 const StridedDeviceAddressRegionKHR * pCallableShaderBindingTable,
6623 DeviceAddress indirectDeviceAddress,
6624 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6625 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6626 // wrapper function for command vkCmdTraceRaysIndirectKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdTraceRaysIndirectKHR.html
6627 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6628 void traceRaysIndirectKHR( const StridedDeviceAddressRegionKHR & raygenShaderBindingTable,
6629 const StridedDeviceAddressRegionKHR & missShaderBindingTable,
6630 const StridedDeviceAddressRegionKHR & hitShaderBindingTable,
6631 const StridedDeviceAddressRegionKHR & callableShaderBindingTable,
6632 DeviceAddress indirectDeviceAddress,
6633 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6634 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6635
6636 // wrapper function for command vkCmdSetRayTracingPipelineStackSizeKHR, see
6637 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRayTracingPipelineStackSizeKHR.html
6638 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6639 void setRayTracingPipelineStackSizeKHR( uint32_t pipelineStackSize, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6640
6641 //=== VK_NV_shading_rate_image ===
6642
6643 // wrapper function for command vkCmdBindShadingRateImageNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindShadingRateImageNV.html
6644 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6645 void bindShadingRateImageNV( ImageView imageView,
6646 ImageLayout imageLayout,
6647 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6648
6649 // wrapper function for command vkCmdSetViewportShadingRatePaletteNV, see
6650 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportShadingRatePaletteNV.html
6651 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6652 void setViewportShadingRatePaletteNV( uint32_t firstViewport,
6653 uint32_t viewportCount,
6654 const ShadingRatePaletteNV * pShadingRatePalettes,
6655 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6656 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6657 // wrapper function for command vkCmdSetViewportShadingRatePaletteNV, see
6658 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportShadingRatePaletteNV.html
6659 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6660 void setViewportShadingRatePaletteNV( uint32_t firstViewport,
6661 ArrayProxy<const ShadingRatePaletteNV> const & shadingRatePalettes,
6662 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6663 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6664
6665 // wrapper function for command vkCmdSetCoarseSampleOrderNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoarseSampleOrderNV.html
6666 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6667 void setCoarseSampleOrderNV( CoarseSampleOrderTypeNV sampleOrderType,
6668 uint32_t customSampleOrderCount,
6669 const CoarseSampleOrderCustomNV * pCustomSampleOrders,
6670 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6671 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6672 // wrapper function for command vkCmdSetCoarseSampleOrderNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoarseSampleOrderNV.html
6673 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6674 void setCoarseSampleOrderNV( CoarseSampleOrderTypeNV sampleOrderType,
6675 ArrayProxy<const CoarseSampleOrderCustomNV> const & customSampleOrders,
6676 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6677 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6678
6679 //=== VK_NV_ray_tracing ===
6680
6681 // wrapper function for command vkCmdBuildAccelerationStructureNV, see
6682 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildAccelerationStructureNV.html
6683 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6684 void buildAccelerationStructureNV( const AccelerationStructureInfoNV * pInfo,
6685 Buffer instanceData,
6686 DeviceSize instanceOffset,
6687 Bool32 update,
6688 AccelerationStructureNV dst,
6689 AccelerationStructureNV src,
6690 Buffer scratch,
6691 DeviceSize scratchOffset,
6692 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6693 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6694 // wrapper function for command vkCmdBuildAccelerationStructureNV, see
6695 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildAccelerationStructureNV.html
6696 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6697 void buildAccelerationStructureNV( const AccelerationStructureInfoNV & info,
6698 Buffer instanceData,
6699 DeviceSize instanceOffset,
6700 Bool32 update,
6701 AccelerationStructureNV dst,
6702 AccelerationStructureNV src,
6703 Buffer scratch,
6704 DeviceSize scratchOffset,
6705 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6706 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6707
6708 // wrapper function for command vkCmdCopyAccelerationStructureNV, see
6709 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyAccelerationStructureNV.html
6710 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6711 void copyAccelerationStructureNV( AccelerationStructureNV dst,
6712 AccelerationStructureNV src,
6713 CopyAccelerationStructureModeKHR mode,
6714 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6715
6716 // wrapper function for command vkCmdTraceRaysNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdTraceRaysNV.html
6717 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6718 void traceRaysNV( Buffer raygenShaderBindingTableBuffer,
6719 DeviceSize raygenShaderBindingOffset,
6720 Buffer missShaderBindingTableBuffer,
6721 DeviceSize missShaderBindingOffset,
6722 DeviceSize missShaderBindingStride,
6723 Buffer hitShaderBindingTableBuffer,
6724 DeviceSize hitShaderBindingOffset,
6725 DeviceSize hitShaderBindingStride,
6726 Buffer callableShaderBindingTableBuffer,
6727 DeviceSize callableShaderBindingOffset,
6728 DeviceSize callableShaderBindingStride,
6729 uint32_t width,
6730 uint32_t height,
6731 uint32_t depth,
6732 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6733
6734 // wrapper function for command vkCmdWriteAccelerationStructuresPropertiesNV, see
6735 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteAccelerationStructuresPropertiesNV.html
6736 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6737 void writeAccelerationStructuresPropertiesNV( uint32_t accelerationStructureCount,
6738 const AccelerationStructureNV * pAccelerationStructures,
6739 QueryType queryType,
6740 QueryPool queryPool,
6741 uint32_t firstQuery,
6742 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6743 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6744 // wrapper function for command vkCmdWriteAccelerationStructuresPropertiesNV, see
6745 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteAccelerationStructuresPropertiesNV.html
6746 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6747 void writeAccelerationStructuresPropertiesNV( ArrayProxy<const AccelerationStructureNV> const & accelerationStructures,
6748 QueryType queryType,
6749 QueryPool queryPool,
6750 uint32_t firstQuery,
6751 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6752 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6753
6754 //=== VK_KHR_draw_indirect_count ===
6755
6756 // wrapper function for command vkCmdDrawIndirectCountKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirectCountKHR.html
6757 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6758 void drawIndirectCountKHR( Buffer buffer,
6759 DeviceSize offset,
6760 Buffer countBuffer,
6761 DeviceSize countBufferOffset,
6762 uint32_t maxDrawCount,
6763 uint32_t stride,
6764 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6765
6766 // wrapper function for command vkCmdDrawIndexedIndirectCountKHR, see
6767 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexedIndirectCountKHR.html
6768 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6769 void drawIndexedIndirectCountKHR( Buffer buffer,
6770 DeviceSize offset,
6771 Buffer countBuffer,
6772 DeviceSize countBufferOffset,
6773 uint32_t maxDrawCount,
6774 uint32_t stride,
6775 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6776
6777 //=== VK_AMD_buffer_marker ===
6778
6779 // wrapper function for command vkCmdWriteBufferMarkerAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteBufferMarkerAMD.html
6780 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6781 void writeBufferMarkerAMD( PipelineStageFlagBits pipelineStage,
6782 Buffer dstBuffer,
6783 DeviceSize dstOffset,
6784 uint32_t marker,
6785 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6786
6787 // wrapper function for command vkCmdWriteBufferMarker2AMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteBufferMarker2AMD.html
6788 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6789 void writeBufferMarker2AMD( PipelineStageFlags2 stage,
6790 Buffer dstBuffer,
6791 DeviceSize dstOffset,
6792 uint32_t marker,
6793 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6794
6795 //=== VK_NV_mesh_shader ===
6796
6797 // wrapper function for command vkCmdDrawMeshTasksNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksNV.html
6798 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6799 void drawMeshTasksNV( uint32_t taskCount, uint32_t firstTask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6800
6801 // wrapper function for command vkCmdDrawMeshTasksIndirectNV, see
6802 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksIndirectNV.html
6803 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6804 void drawMeshTasksIndirectNV( Buffer buffer,
6805 DeviceSize offset,
6806 uint32_t drawCount,
6807 uint32_t stride,
6808 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6809
6810 // wrapper function for command vkCmdDrawMeshTasksIndirectCountNV, see
6811 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksIndirectCountNV.html
6812 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6813 void drawMeshTasksIndirectCountNV( Buffer buffer,
6814 DeviceSize offset,
6815 Buffer countBuffer,
6816 DeviceSize countBufferOffset,
6817 uint32_t maxDrawCount,
6818 uint32_t stride,
6819 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6820
6821 //=== VK_NV_scissor_exclusive ===
6822
6823 // wrapper function for command vkCmdSetExclusiveScissorEnableNV, see
6824 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetExclusiveScissorEnableNV.html
6825 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6826 void setExclusiveScissorEnableNV( uint32_t firstExclusiveScissor,
6827 uint32_t exclusiveScissorCount,
6828 const Bool32 * pExclusiveScissorEnables,
6829 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6830 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6831 // wrapper function for command vkCmdSetExclusiveScissorEnableNV, see
6832 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetExclusiveScissorEnableNV.html
6833 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6834 void setExclusiveScissorEnableNV( uint32_t firstExclusiveScissor,
6835 ArrayProxy<const Bool32> const & exclusiveScissorEnables,
6836 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6837 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6838
6839 // wrapper function for command vkCmdSetExclusiveScissorNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetExclusiveScissorNV.html
6840 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6841 void setExclusiveScissorNV( uint32_t firstExclusiveScissor,
6842 uint32_t exclusiveScissorCount,
6843 const Rect2D * pExclusiveScissors,
6844 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6845 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6846 // wrapper function for command vkCmdSetExclusiveScissorNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetExclusiveScissorNV.html
6847 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6848 void setExclusiveScissorNV( uint32_t firstExclusiveScissor,
6849 ArrayProxy<const Rect2D> const & exclusiveScissors,
6850 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6851 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6852
6853 //=== VK_NV_device_diagnostic_checkpoints ===
6854
6855 // wrapper function for command vkCmdSetCheckpointNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCheckpointNV.html
6856 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6857 void setCheckpointNV( const void * pCheckpointMarker, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6858 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6859 // wrapper function for command vkCmdSetCheckpointNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCheckpointNV.html
6860 template <typename CheckpointMarkerType,
6861 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
6862 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6863 void setCheckpointNV( CheckpointMarkerType const & checkpointMarker,
6864 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6865 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6866
6867 //=== VK_INTEL_performance_query ===
6868
6869 // wrapper function for command vkCmdSetPerformanceMarkerINTEL, see
6870 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPerformanceMarkerINTEL.html
6871 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6872 VULKAN_HPP_NODISCARD Result setPerformanceMarkerINTEL( const PerformanceMarkerInfoINTEL * pMarkerInfo,
6873 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6874 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6875 // wrapper function for command vkCmdSetPerformanceMarkerINTEL, see
6876 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPerformanceMarkerINTEL.html
6877 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6878 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
6879 setPerformanceMarkerINTEL( const PerformanceMarkerInfoINTEL & markerInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
6880 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6881
6882 // wrapper function for command vkCmdSetPerformanceStreamMarkerINTEL, see
6883 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPerformanceStreamMarkerINTEL.html
6884 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6885 VULKAN_HPP_NODISCARD Result setPerformanceStreamMarkerINTEL( const PerformanceStreamMarkerInfoINTEL * pMarkerInfo,
6886 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6887 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6888 // wrapper function for command vkCmdSetPerformanceStreamMarkerINTEL, see
6889 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPerformanceStreamMarkerINTEL.html
6890 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6891 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
6892 setPerformanceStreamMarkerINTEL( const PerformanceStreamMarkerInfoINTEL & markerInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
6893 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6894
6895 // wrapper function for command vkCmdSetPerformanceOverrideINTEL, see
6896 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPerformanceOverrideINTEL.html
6897 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6898 VULKAN_HPP_NODISCARD Result setPerformanceOverrideINTEL( const PerformanceOverrideInfoINTEL * pOverrideInfo,
6899 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6900 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6901 // wrapper function for command vkCmdSetPerformanceOverrideINTEL, see
6902 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPerformanceOverrideINTEL.html
6903 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6904 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
6905 setPerformanceOverrideINTEL( const PerformanceOverrideInfoINTEL & overrideInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
6906 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6907
6908 //=== VK_KHR_fragment_shading_rate ===
6909
6910 // wrapper function for command vkCmdSetFragmentShadingRateKHR, see
6911 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFragmentShadingRateKHR.html
6912 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6913 void setFragmentShadingRateKHR( const Extent2D * pFragmentSize,
6914 const FragmentShadingRateCombinerOpKHR combinerOps[2],
6915 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6916 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6917 // wrapper function for command vkCmdSetFragmentShadingRateKHR, see
6918 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFragmentShadingRateKHR.html
6919 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6920 void setFragmentShadingRateKHR( const Extent2D & fragmentSize,
6921 const FragmentShadingRateCombinerOpKHR combinerOps[2],
6922 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6923 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6924
6925 //=== VK_KHR_dynamic_rendering_local_read ===
6926
6927 // wrapper function for command vkCmdSetRenderingAttachmentLocationsKHR, see
6928 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingAttachmentLocationsKHR.html
6929 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6930 void setRenderingAttachmentLocationsKHR( const RenderingAttachmentLocationInfo * pLocationInfo,
6931 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6932 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6933 // wrapper function for command vkCmdSetRenderingAttachmentLocationsKHR, see
6934 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingAttachmentLocationsKHR.html
6935 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6936 void setRenderingAttachmentLocationsKHR( const RenderingAttachmentLocationInfo & locationInfo,
6937 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6938 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6939
6940 // wrapper function for command vkCmdSetRenderingInputAttachmentIndicesKHR, see
6941 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingInputAttachmentIndicesKHR.html
6942 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6943 void setRenderingInputAttachmentIndicesKHR( const RenderingInputAttachmentIndexInfo * pInputAttachmentIndexInfo,
6944 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6945 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6946 // wrapper function for command vkCmdSetRenderingInputAttachmentIndicesKHR, see
6947 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingInputAttachmentIndicesKHR.html
6948 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6949 void setRenderingInputAttachmentIndicesKHR( const RenderingInputAttachmentIndexInfo & inputAttachmentIndexInfo,
6950 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6951 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6952
6953 //=== VK_EXT_line_rasterization ===
6954
6955 // wrapper function for command vkCmdSetLineStippleEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineStippleEXT.html
6956 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6957 void setLineStippleEXT( uint32_t lineStippleFactor,
6958 uint16_t lineStipplePattern,
6959 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6960
6961 //=== VK_EXT_extended_dynamic_state ===
6962
6963 // wrapper function for command vkCmdSetCullModeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCullModeEXT.html
6964 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6965 void setCullModeEXT( CullModeFlags cullMode, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6966
6967 // wrapper function for command vkCmdSetFrontFaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFrontFaceEXT.html
6968 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6969 void setFrontFaceEXT( FrontFace frontFace, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6970
6971 // wrapper function for command vkCmdSetPrimitiveTopologyEXT, see
6972 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPrimitiveTopologyEXT.html
6973 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6974 void setPrimitiveTopologyEXT( PrimitiveTopology primitiveTopology, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6975
6976 // wrapper function for command vkCmdSetViewportWithCountEXT, see
6977 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWithCountEXT.html
6978 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6979 void setViewportWithCountEXT( uint32_t viewportCount,
6980 const Viewport * pViewports,
6981 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6982 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6983 // wrapper function for command vkCmdSetViewportWithCountEXT, see
6984 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWithCountEXT.html
6985 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6986 void setViewportWithCountEXT( ArrayProxy<const Viewport> const & viewports,
6987 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6988 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6989
6990 // wrapper function for command vkCmdSetScissorWithCountEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetScissorWithCountEXT.html
6991 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6992 void setScissorWithCountEXT( uint32_t scissorCount,
6993 const Rect2D * pScissors,
6994 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6995 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6996 // wrapper function for command vkCmdSetScissorWithCountEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetScissorWithCountEXT.html
6997 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
6998 void setScissorWithCountEXT( ArrayProxy<const Rect2D> const & scissors,
6999 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7000 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7001
7002 // wrapper function for command vkCmdBindVertexBuffers2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers2EXT.html
7003 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7004 void bindVertexBuffers2EXT( uint32_t firstBinding,
7005 uint32_t bindingCount,
7006 const Buffer * pBuffers,
7007 const DeviceSize * pOffsets,
7008 const DeviceSize * pSizes,
7009 const DeviceSize * pStrides,
7010 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7011 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7012 // wrapper function for command vkCmdBindVertexBuffers2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers2EXT.html
7013 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7014 void bindVertexBuffers2EXT( uint32_t firstBinding,
7015 ArrayProxy<const Buffer> const & buffers,
7016 ArrayProxy<const DeviceSize> const & offsets,
7017 ArrayProxy<const DeviceSize> const & sizes VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
7018 ArrayProxy<const DeviceSize> const & strides VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
7019 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
7020 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7021
7022 // wrapper function for command vkCmdSetDepthTestEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthTestEnableEXT.html
7023 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7024 void setDepthTestEnableEXT( Bool32 depthTestEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7025
7026 // wrapper function for command vkCmdSetDepthWriteEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthWriteEnableEXT.html
7027 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7028 void setDepthWriteEnableEXT( Bool32 depthWriteEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7029
7030 // wrapper function for command vkCmdSetDepthCompareOpEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthCompareOpEXT.html
7031 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7032 void setDepthCompareOpEXT( CompareOp depthCompareOp, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7033
7034 // wrapper function for command vkCmdSetDepthBoundsTestEnableEXT, see
7035 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBoundsTestEnableEXT.html
7036 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7037 void setDepthBoundsTestEnableEXT( Bool32 depthBoundsTestEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7038
7039 // wrapper function for command vkCmdSetStencilTestEnableEXT, see
7040 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilTestEnableEXT.html
7041 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7042 void setStencilTestEnableEXT( Bool32 stencilTestEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7043
7044 // wrapper function for command vkCmdSetStencilOpEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilOpEXT.html
7045 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7046 void setStencilOpEXT( StencilFaceFlags faceMask,
7047 StencilOp failOp,
7048 StencilOp passOp,
7049 StencilOp depthFailOp,
7050 CompareOp compareOp,
7051 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7052
7053 //=== VK_NV_device_generated_commands ===
7054
7055 // wrapper function for command vkCmdPreprocessGeneratedCommandsNV, see
7056 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPreprocessGeneratedCommandsNV.html
7057 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7058 void preprocessGeneratedCommandsNV( const GeneratedCommandsInfoNV * pGeneratedCommandsInfo,
7059 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7060 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7061 // wrapper function for command vkCmdPreprocessGeneratedCommandsNV, see
7062 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPreprocessGeneratedCommandsNV.html
7063 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7064 void preprocessGeneratedCommandsNV( const GeneratedCommandsInfoNV & generatedCommandsInfo,
7065 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7066 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7067
7068 // wrapper function for command vkCmdExecuteGeneratedCommandsNV, see
7069 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdExecuteGeneratedCommandsNV.html
7070 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7071 void executeGeneratedCommandsNV( Bool32 isPreprocessed,
7072 const GeneratedCommandsInfoNV * pGeneratedCommandsInfo,
7073 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7074 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7075 // wrapper function for command vkCmdExecuteGeneratedCommandsNV, see
7076 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdExecuteGeneratedCommandsNV.html
7077 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7078 void executeGeneratedCommandsNV( Bool32 isPreprocessed,
7079 const GeneratedCommandsInfoNV & generatedCommandsInfo,
7080 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7081 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7082
7083 // wrapper function for command vkCmdBindPipelineShaderGroupNV, see
7084 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindPipelineShaderGroupNV.html
7085 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7086 void bindPipelineShaderGroupNV( PipelineBindPoint pipelineBindPoint,
7087 Pipeline pipeline,
7088 uint32_t groupIndex,
7089 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7090
7091 //=== VK_EXT_depth_bias_control ===
7092
7093 // wrapper function for command vkCmdSetDepthBias2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBias2EXT.html
7094 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7095 void setDepthBias2EXT( const DepthBiasInfoEXT * pDepthBiasInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7096 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7097 // wrapper function for command vkCmdSetDepthBias2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBias2EXT.html
7098 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7099 void setDepthBias2EXT( const DepthBiasInfoEXT & depthBiasInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7100 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7101
7102 //=== VK_KHR_video_encode_queue ===
7103
7104 // wrapper function for command vkCmdEncodeVideoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEncodeVideoKHR.html
7105 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7106 void encodeVideoKHR( const VideoEncodeInfoKHR * pEncodeInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7107 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7108 // wrapper function for command vkCmdEncodeVideoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEncodeVideoKHR.html
7109 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7110 void encodeVideoKHR( const VideoEncodeInfoKHR & encodeInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7111 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7112
7113 #if defined( VK_ENABLE_BETA_EXTENSIONS )
7114 //=== VK_NV_cuda_kernel_launch ===
7115
7116 // wrapper function for command vkCmdCudaLaunchKernelNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCudaLaunchKernelNV.html
7117 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7118 void cudaLaunchKernelNV( const CudaLaunchInfoNV * pLaunchInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7119 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7120 // wrapper function for command vkCmdCudaLaunchKernelNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCudaLaunchKernelNV.html
7121 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7122 void cudaLaunchKernelNV( const CudaLaunchInfoNV & launchInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7123 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7124 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
7125
7126 //=== VK_QCOM_tile_shading ===
7127
7128 // wrapper function for command vkCmdDispatchTileQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchTileQCOM.html
7129 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7130 void dispatchTileQCOM( const DispatchTileInfoQCOM * pDispatchTileInfo,
7131 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7132 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7133 // wrapper function for command vkCmdDispatchTileQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchTileQCOM.html
7134 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7135 void dispatchTileQCOM( const DispatchTileInfoQCOM & dispatchTileInfo,
7136 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7137 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7138
7139 // wrapper function for command vkCmdBeginPerTileExecutionQCOM, see
7140 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginPerTileExecutionQCOM.html
7141 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7142 void beginPerTileExecutionQCOM( const PerTileBeginInfoQCOM * pPerTileBeginInfo,
7143 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7144 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7145 // wrapper function for command vkCmdBeginPerTileExecutionQCOM, see
7146 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginPerTileExecutionQCOM.html
7147 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7148 void beginPerTileExecutionQCOM( const PerTileBeginInfoQCOM & perTileBeginInfo,
7149 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7150 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7151
7152 // wrapper function for command vkCmdEndPerTileExecutionQCOM, see
7153 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndPerTileExecutionQCOM.html
7154 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7155 void endPerTileExecutionQCOM( const PerTileEndInfoQCOM * pPerTileEndInfo,
7156 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7157 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7158 // wrapper function for command vkCmdEndPerTileExecutionQCOM, see
7159 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndPerTileExecutionQCOM.html
7160 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7161 void endPerTileExecutionQCOM( const PerTileEndInfoQCOM & perTileEndInfo,
7162 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7163 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7164
7165 //=== VK_KHR_synchronization2 ===
7166
7167 // wrapper function for command vkCmdSetEvent2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetEvent2KHR.html
7168 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7169 void setEvent2KHR( Event event,
7170 const DependencyInfo * pDependencyInfo,
7171 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7172 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7173 // wrapper function for command vkCmdSetEvent2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetEvent2KHR.html
7174 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7175 void
7176 setEvent2KHR( Event event, const DependencyInfo & dependencyInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7177 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7178
7179 // wrapper function for command vkCmdResetEvent2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResetEvent2KHR.html
7180 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7181 void resetEvent2KHR( Event event, PipelineStageFlags2 stageMask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7182
7183 // wrapper function for command vkCmdWaitEvents2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWaitEvents2KHR.html
7184 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7185 void waitEvents2KHR( uint32_t eventCount,
7186 const Event * pEvents,
7187 const DependencyInfo * pDependencyInfos,
7188 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7189 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7190 // wrapper function for command vkCmdWaitEvents2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWaitEvents2KHR.html
7191 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7192 void waitEvents2KHR( ArrayProxy<const Event> const & events,
7193 ArrayProxy<const DependencyInfo> const & dependencyInfos,
7194 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
7195 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7196
7197 // wrapper function for command vkCmdPipelineBarrier2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPipelineBarrier2KHR.html
7198 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7199 void pipelineBarrier2KHR( const DependencyInfo * pDependencyInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7200 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7201 // wrapper function for command vkCmdPipelineBarrier2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPipelineBarrier2KHR.html
7202 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7203 void pipelineBarrier2KHR( const DependencyInfo & dependencyInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7204 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7205
7206 // wrapper function for command vkCmdWriteTimestamp2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteTimestamp2KHR.html
7207 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7208 void writeTimestamp2KHR( PipelineStageFlags2 stage,
7209 QueryPool queryPool,
7210 uint32_t query,
7211 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7212
7213 //=== VK_EXT_descriptor_buffer ===
7214
7215 // wrapper function for command vkCmdBindDescriptorBuffersEXT, see
7216 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorBuffersEXT.html
7217 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7218 void bindDescriptorBuffersEXT( uint32_t bufferCount,
7219 const DescriptorBufferBindingInfoEXT * pBindingInfos,
7220 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7221 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7222 // wrapper function for command vkCmdBindDescriptorBuffersEXT, see
7223 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorBuffersEXT.html
7224 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7225 void bindDescriptorBuffersEXT( ArrayProxy<const DescriptorBufferBindingInfoEXT> const & bindingInfos,
7226 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7227 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7228
7229 // wrapper function for command vkCmdSetDescriptorBufferOffsetsEXT, see
7230 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDescriptorBufferOffsetsEXT.html
7231 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7232 void setDescriptorBufferOffsetsEXT( PipelineBindPoint pipelineBindPoint,
7233 PipelineLayout layout,
7234 uint32_t firstSet,
7235 uint32_t setCount,
7236 const uint32_t * pBufferIndices,
7237 const DeviceSize * pOffsets,
7238 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7239 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7240 // wrapper function for command vkCmdSetDescriptorBufferOffsetsEXT, see
7241 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDescriptorBufferOffsetsEXT.html
7242 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7243 void setDescriptorBufferOffsetsEXT( PipelineBindPoint pipelineBindPoint,
7244 PipelineLayout layout,
7245 uint32_t firstSet,
7246 ArrayProxy<const uint32_t> const & bufferIndices,
7247 ArrayProxy<const DeviceSize> const & offsets,
7248 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
7249 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7250
7251 // wrapper function for command vkCmdBindDescriptorBufferEmbeddedSamplersEXT, see
7252 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorBufferEmbeddedSamplersEXT.html
7253 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7254 void bindDescriptorBufferEmbeddedSamplersEXT( PipelineBindPoint pipelineBindPoint,
7255 PipelineLayout layout,
7256 uint32_t set,
7257 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7258
7259 //=== VK_NV_fragment_shading_rate_enums ===
7260
7261 // wrapper function for command vkCmdSetFragmentShadingRateEnumNV, see
7262 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFragmentShadingRateEnumNV.html
7263 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7264 void setFragmentShadingRateEnumNV( FragmentShadingRateNV shadingRate,
7265 const FragmentShadingRateCombinerOpKHR combinerOps[2],
7266 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7267
7268 //=== VK_EXT_mesh_shader ===
7269
7270 // wrapper function for command vkCmdDrawMeshTasksEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksEXT.html
7271 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7272 void drawMeshTasksEXT( uint32_t groupCountX,
7273 uint32_t groupCountY,
7274 uint32_t groupCountZ,
7275 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7276
7277 // wrapper function for command vkCmdDrawMeshTasksIndirectEXT, see
7278 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksIndirectEXT.html
7279 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7280 void drawMeshTasksIndirectEXT( Buffer buffer,
7281 DeviceSize offset,
7282 uint32_t drawCount,
7283 uint32_t stride,
7284 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7285
7286 // wrapper function for command vkCmdDrawMeshTasksIndirectCountEXT, see
7287 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksIndirectCountEXT.html
7288 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7289 void drawMeshTasksIndirectCountEXT( Buffer buffer,
7290 DeviceSize offset,
7291 Buffer countBuffer,
7292 DeviceSize countBufferOffset,
7293 uint32_t maxDrawCount,
7294 uint32_t stride,
7295 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7296
7297 //=== VK_KHR_copy_commands2 ===
7298
7299 // wrapper function for command vkCmdCopyBuffer2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBuffer2KHR.html
7300 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7301 void copyBuffer2KHR( const CopyBufferInfo2 * pCopyBufferInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7302 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7303 // wrapper function for command vkCmdCopyBuffer2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBuffer2KHR.html
7304 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7305 void copyBuffer2KHR( const CopyBufferInfo2 & copyBufferInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7306 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7307
7308 // wrapper function for command vkCmdCopyImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImage2KHR.html
7309 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7310 void copyImage2KHR( const CopyImageInfo2 * pCopyImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7311 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7312 // wrapper function for command vkCmdCopyImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImage2KHR.html
7313 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7314 void copyImage2KHR( const CopyImageInfo2 & copyImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7315 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7316
7317 // wrapper function for command vkCmdCopyBufferToImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBufferToImage2KHR.html
7318 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7319 void copyBufferToImage2KHR( const CopyBufferToImageInfo2 * pCopyBufferToImageInfo,
7320 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7321 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7322 // wrapper function for command vkCmdCopyBufferToImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBufferToImage2KHR.html
7323 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7324 void copyBufferToImage2KHR( const CopyBufferToImageInfo2 & copyBufferToImageInfo,
7325 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7326 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7327
7328 // wrapper function for command vkCmdCopyImageToBuffer2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToBuffer2KHR.html
7329 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7330 void copyImageToBuffer2KHR( const CopyImageToBufferInfo2 * pCopyImageToBufferInfo,
7331 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7332 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7333 // wrapper function for command vkCmdCopyImageToBuffer2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToBuffer2KHR.html
7334 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7335 void copyImageToBuffer2KHR( const CopyImageToBufferInfo2 & copyImageToBufferInfo,
7336 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7337 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7338
7339 // wrapper function for command vkCmdBlitImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBlitImage2KHR.html
7340 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7341 void blitImage2KHR( const BlitImageInfo2 * pBlitImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7342 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7343 // wrapper function for command vkCmdBlitImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBlitImage2KHR.html
7344 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7345 void blitImage2KHR( const BlitImageInfo2 & blitImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7346 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7347
7348 // wrapper function for command vkCmdResolveImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResolveImage2KHR.html
7349 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7350 void resolveImage2KHR( const ResolveImageInfo2 * pResolveImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7351 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7352 // wrapper function for command vkCmdResolveImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResolveImage2KHR.html
7353 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7354 void resolveImage2KHR( const ResolveImageInfo2 & resolveImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7355 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7356
7357 //=== VK_EXT_vertex_input_dynamic_state ===
7358
7359 // wrapper function for command vkCmdSetVertexInputEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetVertexInputEXT.html
7360 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7361 void setVertexInputEXT( uint32_t vertexBindingDescriptionCount,
7362 const VertexInputBindingDescription2EXT * pVertexBindingDescriptions,
7363 uint32_t vertexAttributeDescriptionCount,
7364 const VertexInputAttributeDescription2EXT * pVertexAttributeDescriptions,
7365 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7366 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7367 // wrapper function for command vkCmdSetVertexInputEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetVertexInputEXT.html
7368 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7369 void setVertexInputEXT( ArrayProxy<const VertexInputBindingDescription2EXT> const & vertexBindingDescriptions,
7370 ArrayProxy<const VertexInputAttributeDescription2EXT> const & vertexAttributeDescriptions,
7371 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7372 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7373
7374 //=== VK_HUAWEI_subpass_shading ===
7375
7376 // wrapper function for command vkCmdSubpassShadingHUAWEI, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSubpassShadingHUAWEI.html
7377 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7378 void subpassShadingHUAWEI( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7379
7380 //=== VK_HUAWEI_invocation_mask ===
7381
7382 // wrapper function for command vkCmdBindInvocationMaskHUAWEI, see
7383 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindInvocationMaskHUAWEI.html
7384 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7385 void bindInvocationMaskHUAWEI( ImageView imageView,
7386 ImageLayout imageLayout,
7387 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7388
7389 //=== VK_EXT_extended_dynamic_state2 ===
7390
7391 // wrapper function for command vkCmdSetPatchControlPointsEXT, see
7392 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPatchControlPointsEXT.html
7393 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7394 void setPatchControlPointsEXT( uint32_t patchControlPoints, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7395
7396 // wrapper function for command vkCmdSetRasterizerDiscardEnableEXT, see
7397 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRasterizerDiscardEnableEXT.html
7398 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7399 void setRasterizerDiscardEnableEXT( Bool32 rasterizerDiscardEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7400
7401 // wrapper function for command vkCmdSetDepthBiasEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBiasEnableEXT.html
7402 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7403 void setDepthBiasEnableEXT( Bool32 depthBiasEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7404
7405 // wrapper function for command vkCmdSetLogicOpEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLogicOpEXT.html
7406 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7407 void setLogicOpEXT( LogicOp logicOp, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7408
7409 // wrapper function for command vkCmdSetPrimitiveRestartEnableEXT, see
7410 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPrimitiveRestartEnableEXT.html
7411 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7412 void setPrimitiveRestartEnableEXT( Bool32 primitiveRestartEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7413
7414 //=== VK_EXT_color_write_enable ===
7415
7416 // wrapper function for command vkCmdSetColorWriteEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorWriteEnableEXT.html
7417 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7418 void setColorWriteEnableEXT( uint32_t attachmentCount,
7419 const Bool32 * pColorWriteEnables,
7420 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7421 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7422 // wrapper function for command vkCmdSetColorWriteEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorWriteEnableEXT.html
7423 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7424 void setColorWriteEnableEXT( ArrayProxy<const Bool32> const & colorWriteEnables,
7425 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7426 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7427
7428 //=== VK_KHR_ray_tracing_maintenance1 ===
7429
7430 // wrapper function for command vkCmdTraceRaysIndirect2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdTraceRaysIndirect2KHR.html
7431 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7432 void traceRaysIndirect2KHR( DeviceAddress indirectDeviceAddress, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7433
7434 //=== VK_EXT_multi_draw ===
7435
7436 // wrapper function for command vkCmdDrawMultiEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMultiEXT.html
7437 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7438 void drawMultiEXT( uint32_t drawCount,
7439 const MultiDrawInfoEXT * pVertexInfo,
7440 uint32_t instanceCount,
7441 uint32_t firstInstance,
7442 uint32_t stride,
7443 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7444 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7445 // wrapper function for command vkCmdDrawMultiEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMultiEXT.html
7446 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7447 void drawMultiEXT( StridedArrayProxy<const MultiDrawInfoEXT> const & vertexInfo,
7448 uint32_t instanceCount,
7449 uint32_t firstInstance,
7450 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7451 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7452
7453 // wrapper function for command vkCmdDrawMultiIndexedEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMultiIndexedEXT.html
7454 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7455 void drawMultiIndexedEXT( uint32_t drawCount,
7456 const MultiDrawIndexedInfoEXT * pIndexInfo,
7457 uint32_t instanceCount,
7458 uint32_t firstInstance,
7459 uint32_t stride,
7460 const int32_t * pVertexOffset,
7461 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7462 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7463 // wrapper function for command vkCmdDrawMultiIndexedEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMultiIndexedEXT.html
7464 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7465 void drawMultiIndexedEXT( StridedArrayProxy<const MultiDrawIndexedInfoEXT> const & indexInfo,
7466 uint32_t instanceCount,
7467 uint32_t firstInstance,
7468 Optional<const int32_t> vertexOffset VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
7469 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7470 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7471
7472 //=== VK_EXT_opacity_micromap ===
7473
7474 // wrapper function for command vkCmdBuildMicromapsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildMicromapsEXT.html
7475 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7476 void buildMicromapsEXT( uint32_t infoCount,
7477 const MicromapBuildInfoEXT * pInfos,
7478 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7479 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7480 // wrapper function for command vkCmdBuildMicromapsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildMicromapsEXT.html
7481 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7482 void buildMicromapsEXT( ArrayProxy<const MicromapBuildInfoEXT> const & infos,
7483 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7484 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7485
7486 // wrapper function for command vkCmdCopyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMicromapEXT.html
7487 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7488 void copyMicromapEXT( const CopyMicromapInfoEXT * pInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7489 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7490 // wrapper function for command vkCmdCopyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMicromapEXT.html
7491 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7492 void copyMicromapEXT( const CopyMicromapInfoEXT & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7493 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7494
7495 // wrapper function for command vkCmdCopyMicromapToMemoryEXT, see
7496 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMicromapToMemoryEXT.html
7497 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7498 void copyMicromapToMemoryEXT( const CopyMicromapToMemoryInfoEXT * pInfo,
7499 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7500 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7501 // wrapper function for command vkCmdCopyMicromapToMemoryEXT, see
7502 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMicromapToMemoryEXT.html
7503 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7504 void copyMicromapToMemoryEXT( const CopyMicromapToMemoryInfoEXT & info,
7505 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7506 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7507
7508 // wrapper function for command vkCmdCopyMemoryToMicromapEXT, see
7509 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToMicromapEXT.html
7510 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7511 void copyMemoryToMicromapEXT( const CopyMemoryToMicromapInfoEXT * pInfo,
7512 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7513 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7514 // wrapper function for command vkCmdCopyMemoryToMicromapEXT, see
7515 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToMicromapEXT.html
7516 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7517 void copyMemoryToMicromapEXT( const CopyMemoryToMicromapInfoEXT & info,
7518 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7519 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7520
7521 // wrapper function for command vkCmdWriteMicromapsPropertiesEXT, see
7522 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteMicromapsPropertiesEXT.html
7523 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7524 void writeMicromapsPropertiesEXT( uint32_t micromapCount,
7525 const MicromapEXT * pMicromaps,
7526 QueryType queryType,
7527 QueryPool queryPool,
7528 uint32_t firstQuery,
7529 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7530 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7531 // wrapper function for command vkCmdWriteMicromapsPropertiesEXT, see
7532 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteMicromapsPropertiesEXT.html
7533 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7534 void writeMicromapsPropertiesEXT( ArrayProxy<const MicromapEXT> const & micromaps,
7535 QueryType queryType,
7536 QueryPool queryPool,
7537 uint32_t firstQuery,
7538 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7539 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7540
7541 //=== VK_HUAWEI_cluster_culling_shader ===
7542
7543 // wrapper function for command vkCmdDrawClusterHUAWEI, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawClusterHUAWEI.html
7544 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7545 void drawClusterHUAWEI( uint32_t groupCountX,
7546 uint32_t groupCountY,
7547 uint32_t groupCountZ,
7548 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7549
7550 // wrapper function for command vkCmdDrawClusterIndirectHUAWEI, see
7551 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawClusterIndirectHUAWEI.html
7552 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7553 void drawClusterIndirectHUAWEI( Buffer buffer, DeviceSize offset, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7554
7555 //=== VK_NV_copy_memory_indirect ===
7556
7557 // wrapper function for command vkCmdCopyMemoryIndirectNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryIndirectNV.html
7558 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7559 void copyMemoryIndirectNV( DeviceAddress copyBufferAddress,
7560 uint32_t copyCount,
7561 uint32_t stride,
7562 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7563
7564 // wrapper function for command vkCmdCopyMemoryToImageIndirectNV, see
7565 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToImageIndirectNV.html
7566 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7567 void copyMemoryToImageIndirectNV( DeviceAddress copyBufferAddress,
7568 uint32_t copyCount,
7569 uint32_t stride,
7570 Image dstImage,
7571 ImageLayout dstImageLayout,
7572 const ImageSubresourceLayers * pImageSubresources,
7573 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7574 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7575 // wrapper function for command vkCmdCopyMemoryToImageIndirectNV, see
7576 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToImageIndirectNV.html
7577 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7578 void copyMemoryToImageIndirectNV( DeviceAddress copyBufferAddress,
7579 uint32_t stride,
7580 Image dstImage,
7581 ImageLayout dstImageLayout,
7582 ArrayProxy<const ImageSubresourceLayers> const & imageSubresources,
7583 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7584 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7585
7586 //=== VK_NV_memory_decompression ===
7587
7588 // wrapper function for command vkCmdDecompressMemoryNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecompressMemoryNV.html
7589 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7590 void decompressMemoryNV( uint32_t decompressRegionCount,
7591 const DecompressMemoryRegionNV * pDecompressMemoryRegions,
7592 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7593 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7594 // wrapper function for command vkCmdDecompressMemoryNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecompressMemoryNV.html
7595 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7596 void decompressMemoryNV( ArrayProxy<const DecompressMemoryRegionNV> const & decompressMemoryRegions,
7597 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7598 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7599
7600 // wrapper function for command vkCmdDecompressMemoryIndirectCountNV, see
7601 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecompressMemoryIndirectCountNV.html
7602 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7603 void decompressMemoryIndirectCountNV( DeviceAddress indirectCommandsAddress,
7604 DeviceAddress indirectCommandsCountAddress,
7605 uint32_t stride,
7606 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7607
7608 //=== VK_NV_device_generated_commands_compute ===
7609
7610 // wrapper function for command vkCmdUpdatePipelineIndirectBufferNV, see
7611 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdUpdatePipelineIndirectBufferNV.html
7612 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7613 void updatePipelineIndirectBufferNV( PipelineBindPoint pipelineBindPoint,
7614 Pipeline pipeline,
7615 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7616
7617 //=== VK_EXT_extended_dynamic_state3 ===
7618
7619 // wrapper function for command vkCmdSetDepthClampEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthClampEnableEXT.html
7620 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7621 void setDepthClampEnableEXT( Bool32 depthClampEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7622
7623 // wrapper function for command vkCmdSetPolygonModeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPolygonModeEXT.html
7624 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7625 void setPolygonModeEXT( PolygonMode polygonMode, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7626
7627 // wrapper function for command vkCmdSetRasterizationSamplesEXT, see
7628 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRasterizationSamplesEXT.html
7629 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7630 void setRasterizationSamplesEXT( SampleCountFlagBits rasterizationSamples,
7631 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7632
7633 // wrapper function for command vkCmdSetSampleMaskEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetSampleMaskEXT.html
7634 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7635 void setSampleMaskEXT( SampleCountFlagBits samples,
7636 const SampleMask * pSampleMask,
7637 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7638 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7639 // wrapper function for command vkCmdSetSampleMaskEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetSampleMaskEXT.html
7640 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7641 void setSampleMaskEXT( SampleCountFlagBits samples,
7642 ArrayProxy<const SampleMask> const & sampleMask VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
7643 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
7644 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7645
7646 // wrapper function for command vkCmdSetAlphaToCoverageEnableEXT, see
7647 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetAlphaToCoverageEnableEXT.html
7648 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7649 void setAlphaToCoverageEnableEXT( Bool32 alphaToCoverageEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7650
7651 // wrapper function for command vkCmdSetAlphaToOneEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetAlphaToOneEnableEXT.html
7652 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7653 void setAlphaToOneEnableEXT( Bool32 alphaToOneEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7654
7655 // wrapper function for command vkCmdSetLogicOpEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLogicOpEnableEXT.html
7656 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7657 void setLogicOpEnableEXT( Bool32 logicOpEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7658
7659 // wrapper function for command vkCmdSetColorBlendEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorBlendEnableEXT.html
7660 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7661 void setColorBlendEnableEXT( uint32_t firstAttachment,
7662 uint32_t attachmentCount,
7663 const Bool32 * pColorBlendEnables,
7664 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7665 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7666 // wrapper function for command vkCmdSetColorBlendEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorBlendEnableEXT.html
7667 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7668 void setColorBlendEnableEXT( uint32_t firstAttachment,
7669 ArrayProxy<const Bool32> const & colorBlendEnables,
7670 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7671 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7672
7673 // wrapper function for command vkCmdSetColorBlendEquationEXT, see
7674 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorBlendEquationEXT.html
7675 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7676 void setColorBlendEquationEXT( uint32_t firstAttachment,
7677 uint32_t attachmentCount,
7678 const ColorBlendEquationEXT * pColorBlendEquations,
7679 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7680 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7681 // wrapper function for command vkCmdSetColorBlendEquationEXT, see
7682 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorBlendEquationEXT.html
7683 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7684 void setColorBlendEquationEXT( uint32_t firstAttachment,
7685 ArrayProxy<const ColorBlendEquationEXT> const & colorBlendEquations,
7686 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7687 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7688
7689 // wrapper function for command vkCmdSetColorWriteMaskEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorWriteMaskEXT.html
7690 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7691 void setColorWriteMaskEXT( uint32_t firstAttachment,
7692 uint32_t attachmentCount,
7693 const ColorComponentFlags * pColorWriteMasks,
7694 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7695 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7696 // wrapper function for command vkCmdSetColorWriteMaskEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorWriteMaskEXT.html
7697 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7698 void setColorWriteMaskEXT( uint32_t firstAttachment,
7699 ArrayProxy<const ColorComponentFlags> const & colorWriteMasks,
7700 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7701 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7702
7703 // wrapper function for command vkCmdSetTessellationDomainOriginEXT, see
7704 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetTessellationDomainOriginEXT.html
7705 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7706 void setTessellationDomainOriginEXT( TessellationDomainOrigin domainOrigin,
7707 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7708
7709 // wrapper function for command vkCmdSetRasterizationStreamEXT, see
7710 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRasterizationStreamEXT.html
7711 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7712 void setRasterizationStreamEXT( uint32_t rasterizationStream, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7713
7714 // wrapper function for command vkCmdSetConservativeRasterizationModeEXT, see
7715 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetConservativeRasterizationModeEXT.html
7716 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7717 void setConservativeRasterizationModeEXT( ConservativeRasterizationModeEXT conservativeRasterizationMode,
7718 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7719
7720 // wrapper function for command vkCmdSetExtraPrimitiveOverestimationSizeEXT, see
7721 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetExtraPrimitiveOverestimationSizeEXT.html
7722 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7723 void setExtraPrimitiveOverestimationSizeEXT( float extraPrimitiveOverestimationSize,
7724 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7725
7726 // wrapper function for command vkCmdSetDepthClipEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthClipEnableEXT.html
7727 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7728 void setDepthClipEnableEXT( Bool32 depthClipEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7729
7730 // wrapper function for command vkCmdSetSampleLocationsEnableEXT, see
7731 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetSampleLocationsEnableEXT.html
7732 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7733 void setSampleLocationsEnableEXT( Bool32 sampleLocationsEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7734
7735 // wrapper function for command vkCmdSetColorBlendAdvancedEXT, see
7736 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorBlendAdvancedEXT.html
7737 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7738 void setColorBlendAdvancedEXT( uint32_t firstAttachment,
7739 uint32_t attachmentCount,
7740 const ColorBlendAdvancedEXT * pColorBlendAdvanced,
7741 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7742 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7743 // wrapper function for command vkCmdSetColorBlendAdvancedEXT, see
7744 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorBlendAdvancedEXT.html
7745 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7746 void setColorBlendAdvancedEXT( uint32_t firstAttachment,
7747 ArrayProxy<const ColorBlendAdvancedEXT> const & colorBlendAdvanced,
7748 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7749 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7750
7751 // wrapper function for command vkCmdSetProvokingVertexModeEXT, see
7752 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetProvokingVertexModeEXT.html
7753 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7754 void setProvokingVertexModeEXT( ProvokingVertexModeEXT provokingVertexMode,
7755 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7756
7757 // wrapper function for command vkCmdSetLineRasterizationModeEXT, see
7758 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineRasterizationModeEXT.html
7759 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7760 void setLineRasterizationModeEXT( LineRasterizationModeEXT lineRasterizationMode,
7761 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7762
7763 // wrapper function for command vkCmdSetLineStippleEnableEXT, see
7764 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineStippleEnableEXT.html
7765 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7766 void setLineStippleEnableEXT( Bool32 stippledLineEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7767
7768 // wrapper function for command vkCmdSetDepthClipNegativeOneToOneEXT, see
7769 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthClipNegativeOneToOneEXT.html
7770 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7771 void setDepthClipNegativeOneToOneEXT( Bool32 negativeOneToOne, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7772
7773 // wrapper function for command vkCmdSetViewportWScalingEnableNV, see
7774 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWScalingEnableNV.html
7775 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7776 void setViewportWScalingEnableNV( Bool32 viewportWScalingEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7777
7778 // wrapper function for command vkCmdSetViewportSwizzleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportSwizzleNV.html
7779 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7780 void setViewportSwizzleNV( uint32_t firstViewport,
7781 uint32_t viewportCount,
7782 const ViewportSwizzleNV * pViewportSwizzles,
7783 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7784 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7785 // wrapper function for command vkCmdSetViewportSwizzleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportSwizzleNV.html
7786 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7787 void setViewportSwizzleNV( uint32_t firstViewport,
7788 ArrayProxy<const ViewportSwizzleNV> const & viewportSwizzles,
7789 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7790 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7791
7792 // wrapper function for command vkCmdSetCoverageToColorEnableNV, see
7793 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageToColorEnableNV.html
7794 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7795 void setCoverageToColorEnableNV( Bool32 coverageToColorEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7796
7797 // wrapper function for command vkCmdSetCoverageToColorLocationNV, see
7798 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageToColorLocationNV.html
7799 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7800 void setCoverageToColorLocationNV( uint32_t coverageToColorLocation,
7801 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7802
7803 // wrapper function for command vkCmdSetCoverageModulationModeNV, see
7804 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageModulationModeNV.html
7805 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7806 void setCoverageModulationModeNV( CoverageModulationModeNV coverageModulationMode,
7807 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7808
7809 // wrapper function for command vkCmdSetCoverageModulationTableEnableNV, see
7810 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageModulationTableEnableNV.html
7811 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7812 void setCoverageModulationTableEnableNV( Bool32 coverageModulationTableEnable,
7813 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7814
7815 // wrapper function for command vkCmdSetCoverageModulationTableNV, see
7816 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageModulationTableNV.html
7817 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7818 void setCoverageModulationTableNV( uint32_t coverageModulationTableCount,
7819 const float * pCoverageModulationTable,
7820 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7821 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7822 // wrapper function for command vkCmdSetCoverageModulationTableNV, see
7823 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageModulationTableNV.html
7824 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7825 void setCoverageModulationTableNV( ArrayProxy<const float> const & coverageModulationTable,
7826 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7827 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7828
7829 // wrapper function for command vkCmdSetShadingRateImageEnableNV, see
7830 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetShadingRateImageEnableNV.html
7831 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7832 void setShadingRateImageEnableNV( Bool32 shadingRateImageEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7833
7834 // wrapper function for command vkCmdSetRepresentativeFragmentTestEnableNV, see
7835 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRepresentativeFragmentTestEnableNV.html
7836 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7837 void setRepresentativeFragmentTestEnableNV( Bool32 representativeFragmentTestEnable,
7838 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7839
7840 // wrapper function for command vkCmdSetCoverageReductionModeNV, see
7841 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageReductionModeNV.html
7842 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7843 void setCoverageReductionModeNV( CoverageReductionModeNV coverageReductionMode,
7844 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7845
7846 //=== VK_ARM_tensors ===
7847
7848 // wrapper function for command vkCmdCopyTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyTensorARM.html
7849 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7850 void copyTensorARM( const CopyTensorInfoARM * pCopyTensorInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7851 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7852 // wrapper function for command vkCmdCopyTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyTensorARM.html
7853 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7854 void copyTensorARM( const CopyTensorInfoARM & copyTensorInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7855 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7856
7857 //=== VK_NV_optical_flow ===
7858
7859 // wrapper function for command vkCmdOpticalFlowExecuteNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdOpticalFlowExecuteNV.html
7860 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7861 void opticalFlowExecuteNV( OpticalFlowSessionNV session,
7862 const OpticalFlowExecuteInfoNV * pExecuteInfo,
7863 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7864 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7865 // wrapper function for command vkCmdOpticalFlowExecuteNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdOpticalFlowExecuteNV.html
7866 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7867 void opticalFlowExecuteNV( OpticalFlowSessionNV session,
7868 const OpticalFlowExecuteInfoNV & executeInfo,
7869 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7870 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7871
7872 //=== VK_KHR_maintenance5 ===
7873
7874 // wrapper function for command vkCmdBindIndexBuffer2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindIndexBuffer2KHR.html
7875 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7876 void bindIndexBuffer2KHR( Buffer buffer,
7877 DeviceSize offset,
7878 DeviceSize size,
7879 IndexType indexType,
7880 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7881
7882 //=== VK_EXT_shader_object ===
7883
7884 // wrapper function for command vkCmdBindShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindShadersEXT.html
7885 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7886 void bindShadersEXT( uint32_t stageCount,
7887 const ShaderStageFlagBits * pStages,
7888 const ShaderEXT * pShaders,
7889 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7890 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7891 // wrapper function for command vkCmdBindShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindShadersEXT.html
7892 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7893 void bindShadersEXT( ArrayProxy<const ShaderStageFlagBits> const & stages,
7894 ArrayProxy<const ShaderEXT> const & shaders,
7895 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
7896 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7897
7898 // wrapper function for command vkCmdSetDepthClampRangeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthClampRangeEXT.html
7899 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7900 void setDepthClampRangeEXT( DepthClampModeEXT depthClampMode,
7901 const DepthClampRangeEXT * pDepthClampRange,
7902 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7903 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7904 // wrapper function for command vkCmdSetDepthClampRangeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthClampRangeEXT.html
7905 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7906 void setDepthClampRangeEXT( DepthClampModeEXT depthClampMode,
7907 Optional<const DepthClampRangeEXT> depthClampRange VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
7908 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7909 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7910
7911 //=== VK_NV_cooperative_vector ===
7912
7913 // wrapper function for command vkCmdConvertCooperativeVectorMatrixNV, see
7914 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdConvertCooperativeVectorMatrixNV.html
7915 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7916 void convertCooperativeVectorMatrixNV( uint32_t infoCount,
7917 const ConvertCooperativeVectorMatrixInfoNV * pInfos,
7918 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7919 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7920 // wrapper function for command vkCmdConvertCooperativeVectorMatrixNV, see
7921 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdConvertCooperativeVectorMatrixNV.html
7922 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7923 void convertCooperativeVectorMatrixNV( ArrayProxy<const ConvertCooperativeVectorMatrixInfoNV> const & infos,
7924 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7925 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7926
7927 //=== VK_ARM_data_graph ===
7928
7929 // wrapper function for command vkCmdDispatchDataGraphARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchDataGraphARM.html
7930 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7931 void dispatchDataGraphARM( DataGraphPipelineSessionARM session,
7932 const DataGraphPipelineDispatchInfoARM * pInfo,
7933 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7934 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7935 // wrapper function for command vkCmdDispatchDataGraphARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchDataGraphARM.html
7936 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7937 void dispatchDataGraphARM( DataGraphPipelineSessionARM session,
7938 Optional<const DataGraphPipelineDispatchInfoARM> info VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
7939 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7940 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7941
7942 //=== VK_EXT_attachment_feedback_loop_dynamic_state ===
7943
7944 // wrapper function for command vkCmdSetAttachmentFeedbackLoopEnableEXT, see
7945 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetAttachmentFeedbackLoopEnableEXT.html
7946 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7947 void setAttachmentFeedbackLoopEnableEXT( ImageAspectFlags aspectMask,
7948 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7949
7950 //=== VK_KHR_line_rasterization ===
7951
7952 // wrapper function for command vkCmdSetLineStippleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineStippleKHR.html
7953 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7954 void setLineStippleKHR( uint32_t lineStippleFactor,
7955 uint16_t lineStipplePattern,
7956 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7957
7958 //=== VK_KHR_maintenance6 ===
7959
7960 // wrapper function for command vkCmdBindDescriptorSets2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorSets2KHR.html
7961 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7962 void bindDescriptorSets2KHR( const BindDescriptorSetsInfo * pBindDescriptorSetsInfo,
7963 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7964 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7965 // wrapper function for command vkCmdBindDescriptorSets2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorSets2KHR.html
7966 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7967 void bindDescriptorSets2KHR( const BindDescriptorSetsInfo & bindDescriptorSetsInfo,
7968 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7969 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7970
7971 // wrapper function for command vkCmdPushConstants2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushConstants2KHR.html
7972 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7973 void pushConstants2KHR( const PushConstantsInfo * pPushConstantsInfo,
7974 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7975 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7976 // wrapper function for command vkCmdPushConstants2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushConstants2KHR.html
7977 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7978 void pushConstants2KHR( const PushConstantsInfo & pushConstantsInfo,
7979 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7980 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7981
7982 // wrapper function for command vkCmdPushDescriptorSet2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSet2KHR.html
7983 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7984 void pushDescriptorSet2KHR( const PushDescriptorSetInfo * pPushDescriptorSetInfo,
7985 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7986 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7987 // wrapper function for command vkCmdPushDescriptorSet2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSet2KHR.html
7988 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7989 void pushDescriptorSet2KHR( const PushDescriptorSetInfo & pushDescriptorSetInfo,
7990 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7991 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7992
7993 // wrapper function for command vkCmdPushDescriptorSetWithTemplate2KHR, see
7994 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplate2KHR.html
7995 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
7996 void pushDescriptorSetWithTemplate2KHR( const PushDescriptorSetWithTemplateInfo * pPushDescriptorSetWithTemplateInfo,
7997 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7998 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7999 // wrapper function for command vkCmdPushDescriptorSetWithTemplate2KHR, see
8000 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplate2KHR.html
8001 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
8002 void pushDescriptorSetWithTemplate2KHR( const PushDescriptorSetWithTemplateInfo & pushDescriptorSetWithTemplateInfo,
8003 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8004 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8005
8006 // wrapper function for command vkCmdSetDescriptorBufferOffsets2EXT, see
8007 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDescriptorBufferOffsets2EXT.html
8008 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
8009 void setDescriptorBufferOffsets2EXT( const SetDescriptorBufferOffsetsInfoEXT * pSetDescriptorBufferOffsetsInfo,
8010 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8011 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8012 // wrapper function for command vkCmdSetDescriptorBufferOffsets2EXT, see
8013 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDescriptorBufferOffsets2EXT.html
8014 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
8015 void setDescriptorBufferOffsets2EXT( const SetDescriptorBufferOffsetsInfoEXT & setDescriptorBufferOffsetsInfo,
8016 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8017 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8018
8019 // wrapper function for command vkCmdBindDescriptorBufferEmbeddedSamplers2EXT, see
8020 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorBufferEmbeddedSamplers2EXT.html
8021 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
8022 void bindDescriptorBufferEmbeddedSamplers2EXT( const BindDescriptorBufferEmbeddedSamplersInfoEXT * pBindDescriptorBufferEmbeddedSamplersInfo,
8023 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8024 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8025 // wrapper function for command vkCmdBindDescriptorBufferEmbeddedSamplers2EXT, see
8026 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorBufferEmbeddedSamplers2EXT.html
8027 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
8028 void bindDescriptorBufferEmbeddedSamplers2EXT( const BindDescriptorBufferEmbeddedSamplersInfoEXT & bindDescriptorBufferEmbeddedSamplersInfo,
8029 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8030 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8031
8032 //=== VK_QCOM_tile_memory_heap ===
8033
8034 // wrapper function for command vkCmdBindTileMemoryQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindTileMemoryQCOM.html
8035 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
8036 void bindTileMemoryQCOM( const TileMemoryBindInfoQCOM * pTileMemoryBindInfo,
8037 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8038 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8039 // wrapper function for command vkCmdBindTileMemoryQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindTileMemoryQCOM.html
8040 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
8041 void bindTileMemoryQCOM( Optional<const TileMemoryBindInfoQCOM> tileMemoryBindInfo VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
8042 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8043 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8044
8045 //=== VK_KHR_copy_memory_indirect ===
8046
8047 // wrapper function for command vkCmdCopyMemoryIndirectKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryIndirectKHR.html
8048 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
8049 void copyMemoryIndirectKHR( const CopyMemoryIndirectInfoKHR * pCopyMemoryIndirectInfo,
8050 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8051 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8052 // wrapper function for command vkCmdCopyMemoryIndirectKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryIndirectKHR.html
8053 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
8054 void copyMemoryIndirectKHR( const CopyMemoryIndirectInfoKHR & copyMemoryIndirectInfo,
8055 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8056 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8057
8058 // wrapper function for command vkCmdCopyMemoryToImageIndirectKHR, see
8059 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToImageIndirectKHR.html
8060 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
8061 void copyMemoryToImageIndirectKHR( const CopyMemoryToImageIndirectInfoKHR * pCopyMemoryToImageIndirectInfo,
8062 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8063 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8064 // wrapper function for command vkCmdCopyMemoryToImageIndirectKHR, see
8065 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToImageIndirectKHR.html
8066 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
8067 void copyMemoryToImageIndirectKHR( const CopyMemoryToImageIndirectInfoKHR & copyMemoryToImageIndirectInfo,
8068 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8069 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8070
8071 //=== VK_EXT_memory_decompression ===
8072
8073 // wrapper function for command vkCmdDecompressMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecompressMemoryEXT.html
8074 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
8075 void decompressMemoryEXT( const DecompressMemoryInfoEXT * pDecompressMemoryInfoEXT,
8076 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8077 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8078 // wrapper function for command vkCmdDecompressMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecompressMemoryEXT.html
8079 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
8080 void decompressMemoryEXT( const DecompressMemoryInfoEXT & decompressMemoryInfoEXT,
8081 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8082 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8083
8084 // wrapper function for command vkCmdDecompressMemoryIndirectCountEXT, see
8085 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecompressMemoryIndirectCountEXT.html
8086 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
8087 void decompressMemoryIndirectCountEXT( MemoryDecompressionMethodFlagsEXT decompressionMethod,
8088 DeviceAddress indirectCommandsAddress,
8089 DeviceAddress indirectCommandsCountAddress,
8090 uint32_t maxDecompressionCount,
8091 uint32_t stride,
8092 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8093
8094 //=== VK_NV_cluster_acceleration_structure ===
8095
8096 // wrapper function for command vkCmdBuildClusterAccelerationStructureIndirectNV, see
8097 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildClusterAccelerationStructureIndirectNV.html
8098 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
8099 void buildClusterAccelerationStructureIndirectNV( const ClusterAccelerationStructureCommandsInfoNV * pCommandInfos,
8100 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8101 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8102 // wrapper function for command vkCmdBuildClusterAccelerationStructureIndirectNV, see
8103 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildClusterAccelerationStructureIndirectNV.html
8104 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
8105 void buildClusterAccelerationStructureIndirectNV( const ClusterAccelerationStructureCommandsInfoNV & commandInfos,
8106 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8107 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8108
8109 //=== VK_NV_partitioned_acceleration_structure ===
8110
8111 // wrapper function for command vkCmdBuildPartitionedAccelerationStructuresNV, see
8112 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildPartitionedAccelerationStructuresNV.html
8113 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
8114 void buildPartitionedAccelerationStructuresNV( const BuildPartitionedAccelerationStructureInfoNV * pBuildInfo,
8115 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8116 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8117 // wrapper function for command vkCmdBuildPartitionedAccelerationStructuresNV, see
8118 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildPartitionedAccelerationStructuresNV.html
8119 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
8120 void buildPartitionedAccelerationStructuresNV( const BuildPartitionedAccelerationStructureInfoNV & buildInfo,
8121 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8122 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8123
8124 //=== VK_EXT_device_generated_commands ===
8125
8126 // wrapper function for command vkCmdPreprocessGeneratedCommandsEXT, see
8127 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPreprocessGeneratedCommandsEXT.html
8128 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
8129 void preprocessGeneratedCommandsEXT( const GeneratedCommandsInfoEXT * pGeneratedCommandsInfo,
8130 CommandBuffer stateCommandBuffer,
8131 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8132 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8133 // wrapper function for command vkCmdPreprocessGeneratedCommandsEXT, see
8134 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPreprocessGeneratedCommandsEXT.html
8135 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
8136 void preprocessGeneratedCommandsEXT( const GeneratedCommandsInfoEXT & generatedCommandsInfo,
8137 CommandBuffer stateCommandBuffer,
8138 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8139 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8140
8141 // wrapper function for command vkCmdExecuteGeneratedCommandsEXT, see
8142 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdExecuteGeneratedCommandsEXT.html
8143 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
8144 void executeGeneratedCommandsEXT( Bool32 isPreprocessed,
8145 const GeneratedCommandsInfoEXT * pGeneratedCommandsInfo,
8146 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8147 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8148 // wrapper function for command vkCmdExecuteGeneratedCommandsEXT, see
8149 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdExecuteGeneratedCommandsEXT.html
8150 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
8151 void executeGeneratedCommandsEXT( Bool32 isPreprocessed,
8152 const GeneratedCommandsInfoEXT & generatedCommandsInfo,
8153 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8154 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8155
8156 //=== VK_EXT_fragment_density_map_offset ===
8157
8158 // wrapper function for command vkCmdEndRendering2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering2EXT.html
8159 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
8160 void endRendering2EXT( const RenderingEndInfoKHR * pRenderingEndInfo,
8161 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8162 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8163 // wrapper function for command vkCmdEndRendering2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering2EXT.html
8164 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
8165 void endRendering2EXT( Optional<const RenderingEndInfoKHR> renderingEndInfo VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
8166 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8167 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8168
8169 //=== VK_EXT_custom_resolve ===
8170
8171 // wrapper function for command vkCmdBeginCustomResolveEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginCustomResolveEXT.html
8172 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
8173 void beginCustomResolveEXT( const BeginCustomResolveInfoEXT * pBeginCustomResolveInfo,
8174 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8175 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8176 // wrapper function for command vkCmdBeginCustomResolveEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginCustomResolveEXT.html
8177 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
8178 void beginCustomResolveEXT( Optional<const BeginCustomResolveInfoEXT> beginCustomResolveInfo VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
8179 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8180 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8181
8182 //=== VK_KHR_maintenance10 ===
8183
8184 // wrapper function for command vkCmdEndRendering2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering2KHR.html
8185 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
8186 void endRendering2KHR( const RenderingEndInfoKHR * pRenderingEndInfo,
8187 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8188 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8189 // wrapper function for command vkCmdEndRendering2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering2KHR.html
8190 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
8191 void endRendering2KHR( Optional<const RenderingEndInfoKHR> renderingEndInfo VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
8192 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8193 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8194
8195 operator VkCommandBuffer() const VULKAN_HPP_NOEXCEPT
8196 {
8197 return m_commandBuffer;
8198 }
8199
8200 explicit operator bool() const VULKAN_HPP_NOEXCEPT
8201 {
8202 return m_commandBuffer != VK_NULL_HANDLE;
8203 }
8204
8205 bool operator!() const VULKAN_HPP_NOEXCEPT
8206 {
8207 return m_commandBuffer == VK_NULL_HANDLE;
8208 }
8209
8210 private:
8211 VkCommandBuffer m_commandBuffer = {};
8212 };
8213
8214 template <>
8215 struct CppType<ObjectType, ObjectType::eCommandBuffer>
8216 {
8217 using Type = CommandBuffer;
8218 };
8219
8220 template <>
8221 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eCommandBuffer>
8222 {
8223 using Type = CommandBuffer;
8224 };
8225
8226 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
8227 template <>
8228 struct CppType<VkCommandBuffer, VK_NULL_HANDLE>
8229 {
8230 using Type = CommandBuffer;
8231 };
8232 #endif
8233
8234 template <>
8235 struct isVulkanHandleType<CommandBuffer>
8236 {
8237 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
8238 };
8239
8240 // wrapper class for handle VkDeviceMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceMemory.html
8241 class DeviceMemory
8242 {
8243 public:
8244 using CType = VkDeviceMemory;
8245 using NativeType = VkDeviceMemory;
8246
8247 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDeviceMemory;
8248 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eDeviceMemory;
8249
8250 public:
8251 DeviceMemory() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
8252
8253 DeviceMemory( DeviceMemory const & rhs ) = default;
8254 DeviceMemory & operator=( DeviceMemory const & rhs ) = default;
8255
8256 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
8257 DeviceMemory( DeviceMemory && rhs ) = default;
8258 DeviceMemory & operator=( DeviceMemory && rhs ) = default;
8259 #else
8260 DeviceMemory( DeviceMemory && rhs ) VULKAN_HPP_NOEXCEPT : m_deviceMemory( exchange( rhs.m_deviceMemory, {} ) ) {}
8261
8262 DeviceMemory & operator=( DeviceMemory && rhs ) VULKAN_HPP_NOEXCEPT
8263 {
8264 m_deviceMemory = exchange( rhs.m_deviceMemory, {} );
8265 return *this;
8266 }
8267 #endif
8268
8269 VULKAN_HPP_CONSTEXPR DeviceMemory( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
8270
8271 VULKAN_HPP_TYPESAFE_EXPLICIT DeviceMemory( VkDeviceMemory deviceMemory ) VULKAN_HPP_NOEXCEPT : m_deviceMemory( deviceMemory ) {}
8272
8273 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
8274 DeviceMemory & operator=( VkDeviceMemory deviceMemory ) VULKAN_HPP_NOEXCEPT
8275 {
8276 m_deviceMemory = deviceMemory;
8277 return *this;
8278 }
8279 #endif
8280
8281 DeviceMemory & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
8282 {
8283 m_deviceMemory = {};
8284 return *this;
8285 }
8286
8287 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDeviceMemory() const VULKAN_HPP_NOEXCEPT
8288 {
8289 return m_deviceMemory;
8290 }
8291
8292 explicit operator bool() const VULKAN_HPP_NOEXCEPT
8293 {
8294 return m_deviceMemory != VK_NULL_HANDLE;
8295 }
8296
8297 bool operator!() const VULKAN_HPP_NOEXCEPT
8298 {
8299 return m_deviceMemory == VK_NULL_HANDLE;
8300 }
8301
8302 private:
8303 VkDeviceMemory m_deviceMemory = {};
8304 };
8305
8306 template <>
8307 struct CppType<ObjectType, ObjectType::eDeviceMemory>
8308 {
8309 using Type = DeviceMemory;
8310 };
8311
8312 template <>
8313 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eDeviceMemory>
8314 {
8315 using Type = DeviceMemory;
8316 };
8317
8318 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
8319 template <>
8320 struct CppType<VkDeviceMemory, VK_NULL_HANDLE>
8321 {
8322 using Type = DeviceMemory;
8323 };
8324 #endif
8325
8326 template <>
8327 struct isVulkanHandleType<DeviceMemory>
8328 {
8329 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
8330 };
8331
8332 // wrapper class for handle VkVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoSessionKHR.html
8333 class VideoSessionKHR
8334 {
8335 public:
8336 using CType = VkVideoSessionKHR;
8337 using NativeType = VkVideoSessionKHR;
8338
8339 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eVideoSessionKHR;
8340 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown;
8341
8342 public:
8343 VideoSessionKHR() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
8344
8345 VideoSessionKHR( VideoSessionKHR const & rhs ) = default;
8346 VideoSessionKHR & operator=( VideoSessionKHR const & rhs ) = default;
8347
8348 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
8349 VideoSessionKHR( VideoSessionKHR && rhs ) = default;
8350 VideoSessionKHR & operator=( VideoSessionKHR && rhs ) = default;
8351 #else
8352 VideoSessionKHR( VideoSessionKHR && rhs ) VULKAN_HPP_NOEXCEPT : m_videoSessionKHR( exchange( rhs.m_videoSessionKHR, {} ) ) {}
8353
8354 VideoSessionKHR & operator=( VideoSessionKHR && rhs ) VULKAN_HPP_NOEXCEPT
8355 {
8356 m_videoSessionKHR = exchange( rhs.m_videoSessionKHR, {} );
8357 return *this;
8358 }
8359 #endif
8360
8361 VULKAN_HPP_CONSTEXPR VideoSessionKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
8362
8363 VULKAN_HPP_TYPESAFE_EXPLICIT VideoSessionKHR( VkVideoSessionKHR videoSessionKHR ) VULKAN_HPP_NOEXCEPT : m_videoSessionKHR( videoSessionKHR ) {}
8364
8365 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
8366 VideoSessionKHR & operator=( VkVideoSessionKHR videoSessionKHR ) VULKAN_HPP_NOEXCEPT
8367 {
8368 m_videoSessionKHR = videoSessionKHR;
8369 return *this;
8370 }
8371 #endif
8372
8373 VideoSessionKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
8374 {
8375 m_videoSessionKHR = {};
8376 return *this;
8377 }
8378
8379 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkVideoSessionKHR() const VULKAN_HPP_NOEXCEPT
8380 {
8381 return m_videoSessionKHR;
8382 }
8383
8384 explicit operator bool() const VULKAN_HPP_NOEXCEPT
8385 {
8386 return m_videoSessionKHR != VK_NULL_HANDLE;
8387 }
8388
8389 bool operator!() const VULKAN_HPP_NOEXCEPT
8390 {
8391 return m_videoSessionKHR == VK_NULL_HANDLE;
8392 }
8393
8394 private:
8395 VkVideoSessionKHR m_videoSessionKHR = {};
8396 };
8397
8398 template <>
8399 struct CppType<ObjectType, ObjectType::eVideoSessionKHR>
8400 {
8401 using Type = VideoSessionKHR;
8402 };
8403
8404 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
8405 template <>
8406 struct CppType<VkVideoSessionKHR, VK_NULL_HANDLE>
8407 {
8408 using Type = VideoSessionKHR;
8409 };
8410 #endif
8411
8412 template <>
8413 struct isVulkanHandleType<VideoSessionKHR>
8414 {
8415 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
8416 };
8417
8418 // wrapper class for handle VkDeferredOperationKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeferredOperationKHR.html
8419 class DeferredOperationKHR
8420 {
8421 public:
8422 using CType = VkDeferredOperationKHR;
8423 using NativeType = VkDeferredOperationKHR;
8424
8425 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDeferredOperationKHR;
8426 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown;
8427
8428 public:
8429 DeferredOperationKHR() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
8430
8431 DeferredOperationKHR( DeferredOperationKHR const & rhs ) = default;
8432 DeferredOperationKHR & operator=( DeferredOperationKHR const & rhs ) = default;
8433
8434 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
8435 DeferredOperationKHR( DeferredOperationKHR && rhs ) = default;
8436 DeferredOperationKHR & operator=( DeferredOperationKHR && rhs ) = default;
8437 #else
8438 DeferredOperationKHR( DeferredOperationKHR && rhs ) VULKAN_HPP_NOEXCEPT : m_deferredOperationKHR( exchange( rhs.m_deferredOperationKHR, {} ) ) {}
8439
8440 DeferredOperationKHR & operator=( DeferredOperationKHR && rhs ) VULKAN_HPP_NOEXCEPT
8441 {
8442 m_deferredOperationKHR = exchange( rhs.m_deferredOperationKHR, {} );
8443 return *this;
8444 }
8445 #endif
8446
8447 VULKAN_HPP_CONSTEXPR DeferredOperationKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
8448
8449 VULKAN_HPP_TYPESAFE_EXPLICIT DeferredOperationKHR( VkDeferredOperationKHR deferredOperationKHR ) VULKAN_HPP_NOEXCEPT
8450 : m_deferredOperationKHR( deferredOperationKHR )
8451 {
8452 }
8453
8454 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
8455 DeferredOperationKHR & operator=( VkDeferredOperationKHR deferredOperationKHR ) VULKAN_HPP_NOEXCEPT
8456 {
8457 m_deferredOperationKHR = deferredOperationKHR;
8458 return *this;
8459 }
8460 #endif
8461
8462 DeferredOperationKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
8463 {
8464 m_deferredOperationKHR = {};
8465 return *this;
8466 }
8467
8468 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDeferredOperationKHR() const VULKAN_HPP_NOEXCEPT
8469 {
8470 return m_deferredOperationKHR;
8471 }
8472
8473 explicit operator bool() const VULKAN_HPP_NOEXCEPT
8474 {
8475 return m_deferredOperationKHR != VK_NULL_HANDLE;
8476 }
8477
8478 bool operator!() const VULKAN_HPP_NOEXCEPT
8479 {
8480 return m_deferredOperationKHR == VK_NULL_HANDLE;
8481 }
8482
8483 private:
8484 VkDeferredOperationKHR m_deferredOperationKHR = {};
8485 };
8486
8487 template <>
8488 struct CppType<ObjectType, ObjectType::eDeferredOperationKHR>
8489 {
8490 using Type = DeferredOperationKHR;
8491 };
8492
8493 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
8494 template <>
8495 struct CppType<VkDeferredOperationKHR, VK_NULL_HANDLE>
8496 {
8497 using Type = DeferredOperationKHR;
8498 };
8499 #endif
8500
8501 template <>
8502 struct isVulkanHandleType<DeferredOperationKHR>
8503 {
8504 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
8505 };
8506
8507 // wrapper class for handle VkBufferCollectionFUCHSIA, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferCollectionFUCHSIA.html
8508 #if defined( VK_USE_PLATFORM_FUCHSIA )
8509 class BufferCollectionFUCHSIA
8510 {
8511 public:
8512 using CType = VkBufferCollectionFUCHSIA;
8513 using NativeType = VkBufferCollectionFUCHSIA;
8514
8515 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eBufferCollectionFUCHSIA;
8516 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eBufferCollectionFUCHSIA;
8517
8518 public:
8519 BufferCollectionFUCHSIA() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
8520
8521 BufferCollectionFUCHSIA( BufferCollectionFUCHSIA const & rhs ) = default;
8522 BufferCollectionFUCHSIA & operator=( BufferCollectionFUCHSIA const & rhs ) = default;
8523
8524 # if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
8525 BufferCollectionFUCHSIA( BufferCollectionFUCHSIA && rhs ) = default;
8526 BufferCollectionFUCHSIA & operator=( BufferCollectionFUCHSIA && rhs ) = default;
8527 # else
8528 BufferCollectionFUCHSIA( BufferCollectionFUCHSIA && rhs ) VULKAN_HPP_NOEXCEPT : m_bufferCollectionFUCHSIA( exchange( rhs.m_bufferCollectionFUCHSIA, {} ) )
8529 {
8530 }
8531
8532 BufferCollectionFUCHSIA & operator=( BufferCollectionFUCHSIA && rhs ) VULKAN_HPP_NOEXCEPT
8533 {
8534 m_bufferCollectionFUCHSIA = exchange( rhs.m_bufferCollectionFUCHSIA, {} );
8535 return *this;
8536 }
8537 # endif
8538
8539 VULKAN_HPP_CONSTEXPR BufferCollectionFUCHSIA( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
8540
8541 VULKAN_HPP_TYPESAFE_EXPLICIT BufferCollectionFUCHSIA( VkBufferCollectionFUCHSIA bufferCollectionFUCHSIA ) VULKAN_HPP_NOEXCEPT
8542 : m_bufferCollectionFUCHSIA( bufferCollectionFUCHSIA )
8543 {
8544 }
8545
8546 # if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
8547 BufferCollectionFUCHSIA & operator=( VkBufferCollectionFUCHSIA bufferCollectionFUCHSIA ) VULKAN_HPP_NOEXCEPT
8548 {
8549 m_bufferCollectionFUCHSIA = bufferCollectionFUCHSIA;
8550 return *this;
8551 }
8552 # endif
8553
8554 BufferCollectionFUCHSIA & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
8555 {
8556 m_bufferCollectionFUCHSIA = {};
8557 return *this;
8558 }
8559
8560 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBufferCollectionFUCHSIA() const VULKAN_HPP_NOEXCEPT
8561 {
8562 return m_bufferCollectionFUCHSIA;
8563 }
8564
8565 explicit operator bool() const VULKAN_HPP_NOEXCEPT
8566 {
8567 return m_bufferCollectionFUCHSIA != VK_NULL_HANDLE;
8568 }
8569
8570 bool operator!() const VULKAN_HPP_NOEXCEPT
8571 {
8572 return m_bufferCollectionFUCHSIA == VK_NULL_HANDLE;
8573 }
8574
8575 private:
8576 VkBufferCollectionFUCHSIA m_bufferCollectionFUCHSIA = {};
8577 };
8578
8579 template <>
8580 struct CppType<ObjectType, ObjectType::eBufferCollectionFUCHSIA>
8581 {
8582 using Type = BufferCollectionFUCHSIA;
8583 };
8584
8585 template <>
8586 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eBufferCollectionFUCHSIA>
8587 {
8588 using Type = BufferCollectionFUCHSIA;
8589 };
8590
8591 # if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
8592 template <>
8593 struct CppType<VkBufferCollectionFUCHSIA, VK_NULL_HANDLE>
8594 {
8595 using Type = BufferCollectionFUCHSIA;
8596 };
8597 # endif
8598
8599 template <>
8600 struct isVulkanHandleType<BufferCollectionFUCHSIA>
8601 {
8602 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
8603 };
8604 #endif /*VK_USE_PLATFORM_FUCHSIA*/
8605
8606 // wrapper class for handle VkBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferView.html
8607 class BufferView
8608 {
8609 public:
8610 using CType = VkBufferView;
8611 using NativeType = VkBufferView;
8612
8613 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eBufferView;
8614 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eBufferView;
8615
8616 public:
8617 BufferView() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
8618
8619 BufferView( BufferView const & rhs ) = default;
8620 BufferView & operator=( BufferView const & rhs ) = default;
8621
8622 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
8623 BufferView( BufferView && rhs ) = default;
8624 BufferView & operator=( BufferView && rhs ) = default;
8625 #else
8626 BufferView( BufferView && rhs ) VULKAN_HPP_NOEXCEPT : m_bufferView( exchange( rhs.m_bufferView, {} ) ) {}
8627
8628 BufferView & operator=( BufferView && rhs ) VULKAN_HPP_NOEXCEPT
8629 {
8630 m_bufferView = exchange( rhs.m_bufferView, {} );
8631 return *this;
8632 }
8633 #endif
8634
8635 VULKAN_HPP_CONSTEXPR BufferView( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
8636
8637 VULKAN_HPP_TYPESAFE_EXPLICIT BufferView( VkBufferView bufferView ) VULKAN_HPP_NOEXCEPT : m_bufferView( bufferView ) {}
8638
8639 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
8640 BufferView & operator=( VkBufferView bufferView ) VULKAN_HPP_NOEXCEPT
8641 {
8642 m_bufferView = bufferView;
8643 return *this;
8644 }
8645 #endif
8646
8647 BufferView & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
8648 {
8649 m_bufferView = {};
8650 return *this;
8651 }
8652
8653 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBufferView() const VULKAN_HPP_NOEXCEPT
8654 {
8655 return m_bufferView;
8656 }
8657
8658 explicit operator bool() const VULKAN_HPP_NOEXCEPT
8659 {
8660 return m_bufferView != VK_NULL_HANDLE;
8661 }
8662
8663 bool operator!() const VULKAN_HPP_NOEXCEPT
8664 {
8665 return m_bufferView == VK_NULL_HANDLE;
8666 }
8667
8668 private:
8669 VkBufferView m_bufferView = {};
8670 };
8671
8672 template <>
8673 struct CppType<ObjectType, ObjectType::eBufferView>
8674 {
8675 using Type = BufferView;
8676 };
8677
8678 template <>
8679 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eBufferView>
8680 {
8681 using Type = BufferView;
8682 };
8683
8684 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
8685 template <>
8686 struct CppType<VkBufferView, VK_NULL_HANDLE>
8687 {
8688 using Type = BufferView;
8689 };
8690 #endif
8691
8692 template <>
8693 struct isVulkanHandleType<BufferView>
8694 {
8695 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
8696 };
8697
8698 // wrapper class for handle VkCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandPool.html
8699 class CommandPool
8700 {
8701 public:
8702 using CType = VkCommandPool;
8703 using NativeType = VkCommandPool;
8704
8705 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eCommandPool;
8706 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eCommandPool;
8707
8708 public:
8709 CommandPool() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
8710
8711 CommandPool( CommandPool const & rhs ) = default;
8712 CommandPool & operator=( CommandPool const & rhs ) = default;
8713
8714 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
8715 CommandPool( CommandPool && rhs ) = default;
8716 CommandPool & operator=( CommandPool && rhs ) = default;
8717 #else
8718 CommandPool( CommandPool && rhs ) VULKAN_HPP_NOEXCEPT : m_commandPool( exchange( rhs.m_commandPool, {} ) ) {}
8719
8720 CommandPool & operator=( CommandPool && rhs ) VULKAN_HPP_NOEXCEPT
8721 {
8722 m_commandPool = exchange( rhs.m_commandPool, {} );
8723 return *this;
8724 }
8725 #endif
8726
8727 VULKAN_HPP_CONSTEXPR CommandPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
8728
8729 VULKAN_HPP_TYPESAFE_EXPLICIT CommandPool( VkCommandPool commandPool ) VULKAN_HPP_NOEXCEPT : m_commandPool( commandPool ) {}
8730
8731 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
8732 CommandPool & operator=( VkCommandPool commandPool ) VULKAN_HPP_NOEXCEPT
8733 {
8734 m_commandPool = commandPool;
8735 return *this;
8736 }
8737 #endif
8738
8739 CommandPool & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
8740 {
8741 m_commandPool = {};
8742 return *this;
8743 }
8744
8745 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCommandPool() const VULKAN_HPP_NOEXCEPT
8746 {
8747 return m_commandPool;
8748 }
8749
8750 explicit operator bool() const VULKAN_HPP_NOEXCEPT
8751 {
8752 return m_commandPool != VK_NULL_HANDLE;
8753 }
8754
8755 bool operator!() const VULKAN_HPP_NOEXCEPT
8756 {
8757 return m_commandPool == VK_NULL_HANDLE;
8758 }
8759
8760 private:
8761 VkCommandPool m_commandPool = {};
8762 };
8763
8764 template <>
8765 struct CppType<ObjectType, ObjectType::eCommandPool>
8766 {
8767 using Type = CommandPool;
8768 };
8769
8770 template <>
8771 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eCommandPool>
8772 {
8773 using Type = CommandPool;
8774 };
8775
8776 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
8777 template <>
8778 struct CppType<VkCommandPool, VK_NULL_HANDLE>
8779 {
8780 using Type = CommandPool;
8781 };
8782 #endif
8783
8784 template <>
8785 struct isVulkanHandleType<CommandPool>
8786 {
8787 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
8788 };
8789
8790 // wrapper class for handle VkPipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCache.html
8791 class PipelineCache
8792 {
8793 public:
8794 using CType = VkPipelineCache;
8795 using NativeType = VkPipelineCache;
8796
8797 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePipelineCache;
8798 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::ePipelineCache;
8799
8800 public:
8801 PipelineCache() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
8802
8803 PipelineCache( PipelineCache const & rhs ) = default;
8804 PipelineCache & operator=( PipelineCache const & rhs ) = default;
8805
8806 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
8807 PipelineCache( PipelineCache && rhs ) = default;
8808 PipelineCache & operator=( PipelineCache && rhs ) = default;
8809 #else
8810 PipelineCache( PipelineCache && rhs ) VULKAN_HPP_NOEXCEPT : m_pipelineCache( exchange( rhs.m_pipelineCache, {} ) ) {}
8811
8812 PipelineCache & operator=( PipelineCache && rhs ) VULKAN_HPP_NOEXCEPT
8813 {
8814 m_pipelineCache = exchange( rhs.m_pipelineCache, {} );
8815 return *this;
8816 }
8817 #endif
8818
8819 VULKAN_HPP_CONSTEXPR PipelineCache( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
8820
8821 VULKAN_HPP_TYPESAFE_EXPLICIT PipelineCache( VkPipelineCache pipelineCache ) VULKAN_HPP_NOEXCEPT : m_pipelineCache( pipelineCache ) {}
8822
8823 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
8824 PipelineCache & operator=( VkPipelineCache pipelineCache ) VULKAN_HPP_NOEXCEPT
8825 {
8826 m_pipelineCache = pipelineCache;
8827 return *this;
8828 }
8829 #endif
8830
8831 PipelineCache & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
8832 {
8833 m_pipelineCache = {};
8834 return *this;
8835 }
8836
8837 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineCache() const VULKAN_HPP_NOEXCEPT
8838 {
8839 return m_pipelineCache;
8840 }
8841
8842 explicit operator bool() const VULKAN_HPP_NOEXCEPT
8843 {
8844 return m_pipelineCache != VK_NULL_HANDLE;
8845 }
8846
8847 bool operator!() const VULKAN_HPP_NOEXCEPT
8848 {
8849 return m_pipelineCache == VK_NULL_HANDLE;
8850 }
8851
8852 private:
8853 VkPipelineCache m_pipelineCache = {};
8854 };
8855
8856 template <>
8857 struct CppType<ObjectType, ObjectType::ePipelineCache>
8858 {
8859 using Type = PipelineCache;
8860 };
8861
8862 template <>
8863 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::ePipelineCache>
8864 {
8865 using Type = PipelineCache;
8866 };
8867
8868 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
8869 template <>
8870 struct CppType<VkPipelineCache, VK_NULL_HANDLE>
8871 {
8872 using Type = PipelineCache;
8873 };
8874 #endif
8875
8876 template <>
8877 struct isVulkanHandleType<PipelineCache>
8878 {
8879 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
8880 };
8881
8882 // wrapper class for handle VkCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCuFunctionNVX.html
8883 class CuFunctionNVX
8884 {
8885 public:
8886 using CType = VkCuFunctionNVX;
8887 using NativeType = VkCuFunctionNVX;
8888
8889 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eCuFunctionNVX;
8890 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eCuFunctionNVX;
8891
8892 public:
8893 CuFunctionNVX() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
8894
8895 CuFunctionNVX( CuFunctionNVX const & rhs ) = default;
8896 CuFunctionNVX & operator=( CuFunctionNVX const & rhs ) = default;
8897
8898 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
8899 CuFunctionNVX( CuFunctionNVX && rhs ) = default;
8900 CuFunctionNVX & operator=( CuFunctionNVX && rhs ) = default;
8901 #else
8902 CuFunctionNVX( CuFunctionNVX && rhs ) VULKAN_HPP_NOEXCEPT : m_cuFunctionNVX( exchange( rhs.m_cuFunctionNVX, {} ) ) {}
8903
8904 CuFunctionNVX & operator=( CuFunctionNVX && rhs ) VULKAN_HPP_NOEXCEPT
8905 {
8906 m_cuFunctionNVX = exchange( rhs.m_cuFunctionNVX, {} );
8907 return *this;
8908 }
8909 #endif
8910
8911 VULKAN_HPP_CONSTEXPR CuFunctionNVX( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
8912
8913 VULKAN_HPP_TYPESAFE_EXPLICIT CuFunctionNVX( VkCuFunctionNVX cuFunctionNVX ) VULKAN_HPP_NOEXCEPT : m_cuFunctionNVX( cuFunctionNVX ) {}
8914
8915 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
8916 CuFunctionNVX & operator=( VkCuFunctionNVX cuFunctionNVX ) VULKAN_HPP_NOEXCEPT
8917 {
8918 m_cuFunctionNVX = cuFunctionNVX;
8919 return *this;
8920 }
8921 #endif
8922
8923 CuFunctionNVX & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
8924 {
8925 m_cuFunctionNVX = {};
8926 return *this;
8927 }
8928
8929 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCuFunctionNVX() const VULKAN_HPP_NOEXCEPT
8930 {
8931 return m_cuFunctionNVX;
8932 }
8933
8934 explicit operator bool() const VULKAN_HPP_NOEXCEPT
8935 {
8936 return m_cuFunctionNVX != VK_NULL_HANDLE;
8937 }
8938
8939 bool operator!() const VULKAN_HPP_NOEXCEPT
8940 {
8941 return m_cuFunctionNVX == VK_NULL_HANDLE;
8942 }
8943
8944 private:
8945 VkCuFunctionNVX m_cuFunctionNVX = {};
8946 };
8947
8948 template <>
8949 struct CppType<ObjectType, ObjectType::eCuFunctionNVX>
8950 {
8951 using Type = CuFunctionNVX;
8952 };
8953
8954 template <>
8955 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eCuFunctionNVX>
8956 {
8957 using Type = CuFunctionNVX;
8958 };
8959
8960 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
8961 template <>
8962 struct CppType<VkCuFunctionNVX, VK_NULL_HANDLE>
8963 {
8964 using Type = CuFunctionNVX;
8965 };
8966 #endif
8967
8968 template <>
8969 struct isVulkanHandleType<CuFunctionNVX>
8970 {
8971 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
8972 };
8973
8974 // wrapper class for handle VkCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCuModuleNVX.html
8975 class CuModuleNVX
8976 {
8977 public:
8978 using CType = VkCuModuleNVX;
8979 using NativeType = VkCuModuleNVX;
8980
8981 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eCuModuleNVX;
8982 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eCuModuleNVX;
8983
8984 public:
8985 CuModuleNVX() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
8986
8987 CuModuleNVX( CuModuleNVX const & rhs ) = default;
8988 CuModuleNVX & operator=( CuModuleNVX const & rhs ) = default;
8989
8990 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
8991 CuModuleNVX( CuModuleNVX && rhs ) = default;
8992 CuModuleNVX & operator=( CuModuleNVX && rhs ) = default;
8993 #else
8994 CuModuleNVX( CuModuleNVX && rhs ) VULKAN_HPP_NOEXCEPT : m_cuModuleNVX( exchange( rhs.m_cuModuleNVX, {} ) ) {}
8995
8996 CuModuleNVX & operator=( CuModuleNVX && rhs ) VULKAN_HPP_NOEXCEPT
8997 {
8998 m_cuModuleNVX = exchange( rhs.m_cuModuleNVX, {} );
8999 return *this;
9000 }
9001 #endif
9002
9003 VULKAN_HPP_CONSTEXPR CuModuleNVX( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
9004
9005 VULKAN_HPP_TYPESAFE_EXPLICIT CuModuleNVX( VkCuModuleNVX cuModuleNVX ) VULKAN_HPP_NOEXCEPT : m_cuModuleNVX( cuModuleNVX ) {}
9006
9007 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
9008 CuModuleNVX & operator=( VkCuModuleNVX cuModuleNVX ) VULKAN_HPP_NOEXCEPT
9009 {
9010 m_cuModuleNVX = cuModuleNVX;
9011 return *this;
9012 }
9013 #endif
9014
9015 CuModuleNVX & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
9016 {
9017 m_cuModuleNVX = {};
9018 return *this;
9019 }
9020
9021 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCuModuleNVX() const VULKAN_HPP_NOEXCEPT
9022 {
9023 return m_cuModuleNVX;
9024 }
9025
9026 explicit operator bool() const VULKAN_HPP_NOEXCEPT
9027 {
9028 return m_cuModuleNVX != VK_NULL_HANDLE;
9029 }
9030
9031 bool operator!() const VULKAN_HPP_NOEXCEPT
9032 {
9033 return m_cuModuleNVX == VK_NULL_HANDLE;
9034 }
9035
9036 private:
9037 VkCuModuleNVX m_cuModuleNVX = {};
9038 };
9039
9040 template <>
9041 struct CppType<ObjectType, ObjectType::eCuModuleNVX>
9042 {
9043 using Type = CuModuleNVX;
9044 };
9045
9046 template <>
9047 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eCuModuleNVX>
9048 {
9049 using Type = CuModuleNVX;
9050 };
9051
9052 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
9053 template <>
9054 struct CppType<VkCuModuleNVX, VK_NULL_HANDLE>
9055 {
9056 using Type = CuModuleNVX;
9057 };
9058 #endif
9059
9060 template <>
9061 struct isVulkanHandleType<CuModuleNVX>
9062 {
9063 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
9064 };
9065
9066 // wrapper class for handle VkCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCudaFunctionNV.html
9067 #if defined( VK_ENABLE_BETA_EXTENSIONS )
9068 class CudaFunctionNV
9069 {
9070 public:
9071 using CType = VkCudaFunctionNV;
9072 using NativeType = VkCudaFunctionNV;
9073
9074 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eCudaFunctionNV;
9075 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eCudaFunctionNV;
9076
9077 public:
9078 CudaFunctionNV() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
9079
9080 CudaFunctionNV( CudaFunctionNV const & rhs ) = default;
9081 CudaFunctionNV & operator=( CudaFunctionNV const & rhs ) = default;
9082
9083 # if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
9084 CudaFunctionNV( CudaFunctionNV && rhs ) = default;
9085 CudaFunctionNV & operator=( CudaFunctionNV && rhs ) = default;
9086 # else
9087 CudaFunctionNV( CudaFunctionNV && rhs ) VULKAN_HPP_NOEXCEPT : m_cudaFunctionNV( exchange( rhs.m_cudaFunctionNV, {} ) ) {}
9088
9089 CudaFunctionNV & operator=( CudaFunctionNV && rhs ) VULKAN_HPP_NOEXCEPT
9090 {
9091 m_cudaFunctionNV = exchange( rhs.m_cudaFunctionNV, {} );
9092 return *this;
9093 }
9094 # endif
9095
9096 VULKAN_HPP_CONSTEXPR CudaFunctionNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
9097
9098 VULKAN_HPP_TYPESAFE_EXPLICIT CudaFunctionNV( VkCudaFunctionNV cudaFunctionNV ) VULKAN_HPP_NOEXCEPT : m_cudaFunctionNV( cudaFunctionNV ) {}
9099
9100 # if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
9101 CudaFunctionNV & operator=( VkCudaFunctionNV cudaFunctionNV ) VULKAN_HPP_NOEXCEPT
9102 {
9103 m_cudaFunctionNV = cudaFunctionNV;
9104 return *this;
9105 }
9106 # endif
9107
9108 CudaFunctionNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
9109 {
9110 m_cudaFunctionNV = {};
9111 return *this;
9112 }
9113
9114 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCudaFunctionNV() const VULKAN_HPP_NOEXCEPT
9115 {
9116 return m_cudaFunctionNV;
9117 }
9118
9119 explicit operator bool() const VULKAN_HPP_NOEXCEPT
9120 {
9121 return m_cudaFunctionNV != VK_NULL_HANDLE;
9122 }
9123
9124 bool operator!() const VULKAN_HPP_NOEXCEPT
9125 {
9126 return m_cudaFunctionNV == VK_NULL_HANDLE;
9127 }
9128
9129 private:
9130 VkCudaFunctionNV m_cudaFunctionNV = {};
9131 };
9132
9133 template <>
9134 struct CppType<ObjectType, ObjectType::eCudaFunctionNV>
9135 {
9136 using Type = CudaFunctionNV;
9137 };
9138
9139 template <>
9140 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eCudaFunctionNV>
9141 {
9142 using Type = CudaFunctionNV;
9143 };
9144
9145 # if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
9146 template <>
9147 struct CppType<VkCudaFunctionNV, VK_NULL_HANDLE>
9148 {
9149 using Type = CudaFunctionNV;
9150 };
9151 # endif
9152
9153 template <>
9154 struct isVulkanHandleType<CudaFunctionNV>
9155 {
9156 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
9157 };
9158 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
9159
9160 // wrapper class for handle VkCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCudaModuleNV.html
9161 #if defined( VK_ENABLE_BETA_EXTENSIONS )
9162 class CudaModuleNV
9163 {
9164 public:
9165 using CType = VkCudaModuleNV;
9166 using NativeType = VkCudaModuleNV;
9167
9168 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eCudaModuleNV;
9169 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eCudaModuleNV;
9170
9171 public:
9172 CudaModuleNV() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
9173
9174 CudaModuleNV( CudaModuleNV const & rhs ) = default;
9175 CudaModuleNV & operator=( CudaModuleNV const & rhs ) = default;
9176
9177 # if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
9178 CudaModuleNV( CudaModuleNV && rhs ) = default;
9179 CudaModuleNV & operator=( CudaModuleNV && rhs ) = default;
9180 # else
9181 CudaModuleNV( CudaModuleNV && rhs ) VULKAN_HPP_NOEXCEPT : m_cudaModuleNV( exchange( rhs.m_cudaModuleNV, {} ) ) {}
9182
9183 CudaModuleNV & operator=( CudaModuleNV && rhs ) VULKAN_HPP_NOEXCEPT
9184 {
9185 m_cudaModuleNV = exchange( rhs.m_cudaModuleNV, {} );
9186 return *this;
9187 }
9188 # endif
9189
9190 VULKAN_HPP_CONSTEXPR CudaModuleNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
9191
9192 VULKAN_HPP_TYPESAFE_EXPLICIT CudaModuleNV( VkCudaModuleNV cudaModuleNV ) VULKAN_HPP_NOEXCEPT : m_cudaModuleNV( cudaModuleNV ) {}
9193
9194 # if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
9195 CudaModuleNV & operator=( VkCudaModuleNV cudaModuleNV ) VULKAN_HPP_NOEXCEPT
9196 {
9197 m_cudaModuleNV = cudaModuleNV;
9198 return *this;
9199 }
9200 # endif
9201
9202 CudaModuleNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
9203 {
9204 m_cudaModuleNV = {};
9205 return *this;
9206 }
9207
9208 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCudaModuleNV() const VULKAN_HPP_NOEXCEPT
9209 {
9210 return m_cudaModuleNV;
9211 }
9212
9213 explicit operator bool() const VULKAN_HPP_NOEXCEPT
9214 {
9215 return m_cudaModuleNV != VK_NULL_HANDLE;
9216 }
9217
9218 bool operator!() const VULKAN_HPP_NOEXCEPT
9219 {
9220 return m_cudaModuleNV == VK_NULL_HANDLE;
9221 }
9222
9223 private:
9224 VkCudaModuleNV m_cudaModuleNV = {};
9225 };
9226
9227 template <>
9228 struct CppType<ObjectType, ObjectType::eCudaModuleNV>
9229 {
9230 using Type = CudaModuleNV;
9231 };
9232
9233 template <>
9234 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eCudaModuleNV>
9235 {
9236 using Type = CudaModuleNV;
9237 };
9238
9239 # if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
9240 template <>
9241 struct CppType<VkCudaModuleNV, VK_NULL_HANDLE>
9242 {
9243 using Type = CudaModuleNV;
9244 };
9245 # endif
9246
9247 template <>
9248 struct isVulkanHandleType<CudaModuleNV>
9249 {
9250 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
9251 };
9252 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
9253
9254 // wrapper class for handle VkDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorPool.html
9255 class DescriptorPool
9256 {
9257 public:
9258 using CType = VkDescriptorPool;
9259 using NativeType = VkDescriptorPool;
9260
9261 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDescriptorPool;
9262 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eDescriptorPool;
9263
9264 public:
9265 DescriptorPool() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
9266
9267 DescriptorPool( DescriptorPool const & rhs ) = default;
9268 DescriptorPool & operator=( DescriptorPool const & rhs ) = default;
9269
9270 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
9271 DescriptorPool( DescriptorPool && rhs ) = default;
9272 DescriptorPool & operator=( DescriptorPool && rhs ) = default;
9273 #else
9274 DescriptorPool( DescriptorPool && rhs ) VULKAN_HPP_NOEXCEPT : m_descriptorPool( exchange( rhs.m_descriptorPool, {} ) ) {}
9275
9276 DescriptorPool & operator=( DescriptorPool && rhs ) VULKAN_HPP_NOEXCEPT
9277 {
9278 m_descriptorPool = exchange( rhs.m_descriptorPool, {} );
9279 return *this;
9280 }
9281 #endif
9282
9283 VULKAN_HPP_CONSTEXPR DescriptorPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
9284
9285 VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorPool( VkDescriptorPool descriptorPool ) VULKAN_HPP_NOEXCEPT : m_descriptorPool( descriptorPool ) {}
9286
9287 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
9288 DescriptorPool & operator=( VkDescriptorPool descriptorPool ) VULKAN_HPP_NOEXCEPT
9289 {
9290 m_descriptorPool = descriptorPool;
9291 return *this;
9292 }
9293 #endif
9294
9295 DescriptorPool & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
9296 {
9297 m_descriptorPool = {};
9298 return *this;
9299 }
9300
9301 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorPool() const VULKAN_HPP_NOEXCEPT
9302 {
9303 return m_descriptorPool;
9304 }
9305
9306 explicit operator bool() const VULKAN_HPP_NOEXCEPT
9307 {
9308 return m_descriptorPool != VK_NULL_HANDLE;
9309 }
9310
9311 bool operator!() const VULKAN_HPP_NOEXCEPT
9312 {
9313 return m_descriptorPool == VK_NULL_HANDLE;
9314 }
9315
9316 private:
9317 VkDescriptorPool m_descriptorPool = {};
9318 };
9319
9320 template <>
9321 struct CppType<ObjectType, ObjectType::eDescriptorPool>
9322 {
9323 using Type = DescriptorPool;
9324 };
9325
9326 template <>
9327 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eDescriptorPool>
9328 {
9329 using Type = DescriptorPool;
9330 };
9331
9332 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
9333 template <>
9334 struct CppType<VkDescriptorPool, VK_NULL_HANDLE>
9335 {
9336 using Type = DescriptorPool;
9337 };
9338 #endif
9339
9340 template <>
9341 struct isVulkanHandleType<DescriptorPool>
9342 {
9343 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
9344 };
9345
9346 // wrapper class for handle VkDescriptorSetLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorSetLayout.html
9347 class DescriptorSetLayout
9348 {
9349 public:
9350 using CType = VkDescriptorSetLayout;
9351 using NativeType = VkDescriptorSetLayout;
9352
9353 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDescriptorSetLayout;
9354 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eDescriptorSetLayout;
9355
9356 public:
9357 DescriptorSetLayout() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
9358
9359 DescriptorSetLayout( DescriptorSetLayout const & rhs ) = default;
9360 DescriptorSetLayout & operator=( DescriptorSetLayout const & rhs ) = default;
9361
9362 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
9363 DescriptorSetLayout( DescriptorSetLayout && rhs ) = default;
9364 DescriptorSetLayout & operator=( DescriptorSetLayout && rhs ) = default;
9365 #else
9366 DescriptorSetLayout( DescriptorSetLayout && rhs ) VULKAN_HPP_NOEXCEPT : m_descriptorSetLayout( exchange( rhs.m_descriptorSetLayout, {} ) ) {}
9367
9368 DescriptorSetLayout & operator=( DescriptorSetLayout && rhs ) VULKAN_HPP_NOEXCEPT
9369 {
9370 m_descriptorSetLayout = exchange( rhs.m_descriptorSetLayout, {} );
9371 return *this;
9372 }
9373 #endif
9374
9375 VULKAN_HPP_CONSTEXPR DescriptorSetLayout( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
9376
9377 VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSetLayout( VkDescriptorSetLayout descriptorSetLayout ) VULKAN_HPP_NOEXCEPT
9378 : m_descriptorSetLayout( descriptorSetLayout )
9379 {
9380 }
9381
9382 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
9383 DescriptorSetLayout & operator=( VkDescriptorSetLayout descriptorSetLayout ) VULKAN_HPP_NOEXCEPT
9384 {
9385 m_descriptorSetLayout = descriptorSetLayout;
9386 return *this;
9387 }
9388 #endif
9389
9390 DescriptorSetLayout & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
9391 {
9392 m_descriptorSetLayout = {};
9393 return *this;
9394 }
9395
9396 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorSetLayout() const VULKAN_HPP_NOEXCEPT
9397 {
9398 return m_descriptorSetLayout;
9399 }
9400
9401 explicit operator bool() const VULKAN_HPP_NOEXCEPT
9402 {
9403 return m_descriptorSetLayout != VK_NULL_HANDLE;
9404 }
9405
9406 bool operator!() const VULKAN_HPP_NOEXCEPT
9407 {
9408 return m_descriptorSetLayout == VK_NULL_HANDLE;
9409 }
9410
9411 private:
9412 VkDescriptorSetLayout m_descriptorSetLayout = {};
9413 };
9414
9415 template <>
9416 struct CppType<ObjectType, ObjectType::eDescriptorSetLayout>
9417 {
9418 using Type = DescriptorSetLayout;
9419 };
9420
9421 template <>
9422 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eDescriptorSetLayout>
9423 {
9424 using Type = DescriptorSetLayout;
9425 };
9426
9427 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
9428 template <>
9429 struct CppType<VkDescriptorSetLayout, VK_NULL_HANDLE>
9430 {
9431 using Type = DescriptorSetLayout;
9432 };
9433 #endif
9434
9435 template <>
9436 struct isVulkanHandleType<DescriptorSetLayout>
9437 {
9438 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
9439 };
9440
9441 // wrapper class for handle VkExternalComputeQueueNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalComputeQueueNV.html
9442 class ExternalComputeQueueNV
9443 {
9444 public:
9445 using CType = VkExternalComputeQueueNV;
9446 using NativeType = VkExternalComputeQueueNV;
9447
9448 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eExternalComputeQueueNV;
9449 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown;
9450
9451 public:
9452 ExternalComputeQueueNV() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
9453
9454 ExternalComputeQueueNV( ExternalComputeQueueNV const & rhs ) = default;
9455 ExternalComputeQueueNV & operator=( ExternalComputeQueueNV const & rhs ) = default;
9456
9457 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
9458 ExternalComputeQueueNV( ExternalComputeQueueNV && rhs ) = default;
9459 ExternalComputeQueueNV & operator=( ExternalComputeQueueNV && rhs ) = default;
9460 #else
9461 ExternalComputeQueueNV( ExternalComputeQueueNV && rhs ) VULKAN_HPP_NOEXCEPT : m_externalComputeQueueNV( exchange( rhs.m_externalComputeQueueNV, {} ) ) {}
9462
9463 ExternalComputeQueueNV & operator=( ExternalComputeQueueNV && rhs ) VULKAN_HPP_NOEXCEPT
9464 {
9465 m_externalComputeQueueNV = exchange( rhs.m_externalComputeQueueNV, {} );
9466 return *this;
9467 }
9468 #endif
9469
9470 VULKAN_HPP_CONSTEXPR ExternalComputeQueueNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
9471
9472 ExternalComputeQueueNV( VkExternalComputeQueueNV externalComputeQueueNV ) VULKAN_HPP_NOEXCEPT : m_externalComputeQueueNV( externalComputeQueueNV ) {}
9473
9474 ExternalComputeQueueNV & operator=( VkExternalComputeQueueNV externalComputeQueueNV ) VULKAN_HPP_NOEXCEPT
9475 {
9476 m_externalComputeQueueNV = externalComputeQueueNV;
9477 return *this;
9478 }
9479
9480 ExternalComputeQueueNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
9481 {
9482 m_externalComputeQueueNV = {};
9483 return *this;
9484 }
9485
9486 //=== VK_NV_external_compute_queue ===
9487
9488 // wrapper function for command vkGetExternalComputeQueueDataNV, see
9489 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExternalComputeQueueDataNV.html
9490 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
9491 void
9492 getData( ExternalComputeQueueDataParamsNV * params, void * pData, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9493 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9494 // wrapper function for command vkGetExternalComputeQueueDataNV, see
9495 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExternalComputeQueueDataNV.html
9496 template <typename DataType,
9497 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
9498 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
9499 VULKAN_HPP_NODISCARD std::pair<ExternalComputeQueueDataParamsNV, DataType>
9500 getData( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9501 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9502
9503 operator VkExternalComputeQueueNV() const VULKAN_HPP_NOEXCEPT
9504 {
9505 return m_externalComputeQueueNV;
9506 }
9507
9508 explicit operator bool() const VULKAN_HPP_NOEXCEPT
9509 {
9510 return m_externalComputeQueueNV != VK_NULL_HANDLE;
9511 }
9512
9513 bool operator!() const VULKAN_HPP_NOEXCEPT
9514 {
9515 return m_externalComputeQueueNV == VK_NULL_HANDLE;
9516 }
9517
9518 private:
9519 VkExternalComputeQueueNV m_externalComputeQueueNV = {};
9520 };
9521
9522 template <>
9523 struct CppType<ObjectType, ObjectType::eExternalComputeQueueNV>
9524 {
9525 using Type = ExternalComputeQueueNV;
9526 };
9527
9528 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
9529 template <>
9530 struct CppType<VkExternalComputeQueueNV, VK_NULL_HANDLE>
9531 {
9532 using Type = ExternalComputeQueueNV;
9533 };
9534 #endif
9535
9536 template <>
9537 struct isVulkanHandleType<ExternalComputeQueueNV>
9538 {
9539 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
9540 };
9541
9542 // wrapper class for handle VkFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFramebuffer.html
9543 class Framebuffer
9544 {
9545 public:
9546 using CType = VkFramebuffer;
9547 using NativeType = VkFramebuffer;
9548
9549 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eFramebuffer;
9550 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eFramebuffer;
9551
9552 public:
9553 Framebuffer() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
9554
9555 Framebuffer( Framebuffer const & rhs ) = default;
9556 Framebuffer & operator=( Framebuffer const & rhs ) = default;
9557
9558 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
9559 Framebuffer( Framebuffer && rhs ) = default;
9560 Framebuffer & operator=( Framebuffer && rhs ) = default;
9561 #else
9562 Framebuffer( Framebuffer && rhs ) VULKAN_HPP_NOEXCEPT : m_framebuffer( exchange( rhs.m_framebuffer, {} ) ) {}
9563
9564 Framebuffer & operator=( Framebuffer && rhs ) VULKAN_HPP_NOEXCEPT
9565 {
9566 m_framebuffer = exchange( rhs.m_framebuffer, {} );
9567 return *this;
9568 }
9569 #endif
9570
9571 VULKAN_HPP_CONSTEXPR Framebuffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
9572
9573 VULKAN_HPP_TYPESAFE_EXPLICIT Framebuffer( VkFramebuffer framebuffer ) VULKAN_HPP_NOEXCEPT : m_framebuffer( framebuffer ) {}
9574
9575 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
9576 Framebuffer & operator=( VkFramebuffer framebuffer ) VULKAN_HPP_NOEXCEPT
9577 {
9578 m_framebuffer = framebuffer;
9579 return *this;
9580 }
9581 #endif
9582
9583 Framebuffer & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
9584 {
9585 m_framebuffer = {};
9586 return *this;
9587 }
9588
9589 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkFramebuffer() const VULKAN_HPP_NOEXCEPT
9590 {
9591 return m_framebuffer;
9592 }
9593
9594 explicit operator bool() const VULKAN_HPP_NOEXCEPT
9595 {
9596 return m_framebuffer != VK_NULL_HANDLE;
9597 }
9598
9599 bool operator!() const VULKAN_HPP_NOEXCEPT
9600 {
9601 return m_framebuffer == VK_NULL_HANDLE;
9602 }
9603
9604 private:
9605 VkFramebuffer m_framebuffer = {};
9606 };
9607
9608 template <>
9609 struct CppType<ObjectType, ObjectType::eFramebuffer>
9610 {
9611 using Type = Framebuffer;
9612 };
9613
9614 template <>
9615 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eFramebuffer>
9616 {
9617 using Type = Framebuffer;
9618 };
9619
9620 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
9621 template <>
9622 struct CppType<VkFramebuffer, VK_NULL_HANDLE>
9623 {
9624 using Type = Framebuffer;
9625 };
9626 #endif
9627
9628 template <>
9629 struct isVulkanHandleType<Framebuffer>
9630 {
9631 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
9632 };
9633
9634 // wrapper class for handle VkIndirectCommandsLayoutEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectCommandsLayoutEXT.html
9635 class IndirectCommandsLayoutEXT
9636 {
9637 public:
9638 using CType = VkIndirectCommandsLayoutEXT;
9639 using NativeType = VkIndirectCommandsLayoutEXT;
9640
9641 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eIndirectCommandsLayoutEXT;
9642 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown;
9643
9644 public:
9645 IndirectCommandsLayoutEXT() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
9646
9647 IndirectCommandsLayoutEXT( IndirectCommandsLayoutEXT const & rhs ) = default;
9648 IndirectCommandsLayoutEXT & operator=( IndirectCommandsLayoutEXT const & rhs ) = default;
9649
9650 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
9651 IndirectCommandsLayoutEXT( IndirectCommandsLayoutEXT && rhs ) = default;
9652 IndirectCommandsLayoutEXT & operator=( IndirectCommandsLayoutEXT && rhs ) = default;
9653 #else
9654 IndirectCommandsLayoutEXT( IndirectCommandsLayoutEXT && rhs ) VULKAN_HPP_NOEXCEPT
9655 : m_indirectCommandsLayoutEXT( exchange( rhs.m_indirectCommandsLayoutEXT, {} ) )
9656 {
9657 }
9658
9659 IndirectCommandsLayoutEXT & operator=( IndirectCommandsLayoutEXT && rhs ) VULKAN_HPP_NOEXCEPT
9660 {
9661 m_indirectCommandsLayoutEXT = exchange( rhs.m_indirectCommandsLayoutEXT, {} );
9662 return *this;
9663 }
9664 #endif
9665
9666 VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
9667
9668 VULKAN_HPP_TYPESAFE_EXPLICIT IndirectCommandsLayoutEXT( VkIndirectCommandsLayoutEXT indirectCommandsLayoutEXT ) VULKAN_HPP_NOEXCEPT
9669 : m_indirectCommandsLayoutEXT( indirectCommandsLayoutEXT )
9670 {
9671 }
9672
9673 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
9674 IndirectCommandsLayoutEXT & operator=( VkIndirectCommandsLayoutEXT indirectCommandsLayoutEXT ) VULKAN_HPP_NOEXCEPT
9675 {
9676 m_indirectCommandsLayoutEXT = indirectCommandsLayoutEXT;
9677 return *this;
9678 }
9679 #endif
9680
9681 IndirectCommandsLayoutEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
9682 {
9683 m_indirectCommandsLayoutEXT = {};
9684 return *this;
9685 }
9686
9687 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkIndirectCommandsLayoutEXT() const VULKAN_HPP_NOEXCEPT
9688 {
9689 return m_indirectCommandsLayoutEXT;
9690 }
9691
9692 explicit operator bool() const VULKAN_HPP_NOEXCEPT
9693 {
9694 return m_indirectCommandsLayoutEXT != VK_NULL_HANDLE;
9695 }
9696
9697 bool operator!() const VULKAN_HPP_NOEXCEPT
9698 {
9699 return m_indirectCommandsLayoutEXT == VK_NULL_HANDLE;
9700 }
9701
9702 private:
9703 VkIndirectCommandsLayoutEXT m_indirectCommandsLayoutEXT = {};
9704 };
9705
9706 template <>
9707 struct CppType<ObjectType, ObjectType::eIndirectCommandsLayoutEXT>
9708 {
9709 using Type = IndirectCommandsLayoutEXT;
9710 };
9711
9712 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
9713 template <>
9714 struct CppType<VkIndirectCommandsLayoutEXT, VK_NULL_HANDLE>
9715 {
9716 using Type = IndirectCommandsLayoutEXT;
9717 };
9718 #endif
9719
9720 template <>
9721 struct isVulkanHandleType<IndirectCommandsLayoutEXT>
9722 {
9723 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
9724 };
9725
9726 // wrapper class for handle VkIndirectCommandsLayoutNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectCommandsLayoutNV.html
9727 class IndirectCommandsLayoutNV
9728 {
9729 public:
9730 using CType = VkIndirectCommandsLayoutNV;
9731 using NativeType = VkIndirectCommandsLayoutNV;
9732
9733 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eIndirectCommandsLayoutNV;
9734 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown;
9735
9736 public:
9737 IndirectCommandsLayoutNV() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
9738
9739 IndirectCommandsLayoutNV( IndirectCommandsLayoutNV const & rhs ) = default;
9740 IndirectCommandsLayoutNV & operator=( IndirectCommandsLayoutNV const & rhs ) = default;
9741
9742 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
9743 IndirectCommandsLayoutNV( IndirectCommandsLayoutNV && rhs ) = default;
9744 IndirectCommandsLayoutNV & operator=( IndirectCommandsLayoutNV && rhs ) = default;
9745 #else
9746 IndirectCommandsLayoutNV( IndirectCommandsLayoutNV && rhs ) VULKAN_HPP_NOEXCEPT
9747 : m_indirectCommandsLayoutNV( exchange( rhs.m_indirectCommandsLayoutNV, {} ) )
9748 {
9749 }
9750
9751 IndirectCommandsLayoutNV & operator=( IndirectCommandsLayoutNV && rhs ) VULKAN_HPP_NOEXCEPT
9752 {
9753 m_indirectCommandsLayoutNV = exchange( rhs.m_indirectCommandsLayoutNV, {} );
9754 return *this;
9755 }
9756 #endif
9757
9758 VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
9759
9760 VULKAN_HPP_TYPESAFE_EXPLICIT IndirectCommandsLayoutNV( VkIndirectCommandsLayoutNV indirectCommandsLayoutNV ) VULKAN_HPP_NOEXCEPT
9761 : m_indirectCommandsLayoutNV( indirectCommandsLayoutNV )
9762 {
9763 }
9764
9765 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
9766 IndirectCommandsLayoutNV & operator=( VkIndirectCommandsLayoutNV indirectCommandsLayoutNV ) VULKAN_HPP_NOEXCEPT
9767 {
9768 m_indirectCommandsLayoutNV = indirectCommandsLayoutNV;
9769 return *this;
9770 }
9771 #endif
9772
9773 IndirectCommandsLayoutNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
9774 {
9775 m_indirectCommandsLayoutNV = {};
9776 return *this;
9777 }
9778
9779 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkIndirectCommandsLayoutNV() const VULKAN_HPP_NOEXCEPT
9780 {
9781 return m_indirectCommandsLayoutNV;
9782 }
9783
9784 explicit operator bool() const VULKAN_HPP_NOEXCEPT
9785 {
9786 return m_indirectCommandsLayoutNV != VK_NULL_HANDLE;
9787 }
9788
9789 bool operator!() const VULKAN_HPP_NOEXCEPT
9790 {
9791 return m_indirectCommandsLayoutNV == VK_NULL_HANDLE;
9792 }
9793
9794 private:
9795 VkIndirectCommandsLayoutNV m_indirectCommandsLayoutNV = {};
9796 };
9797
9798 template <>
9799 struct CppType<ObjectType, ObjectType::eIndirectCommandsLayoutNV>
9800 {
9801 using Type = IndirectCommandsLayoutNV;
9802 };
9803
9804 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
9805 template <>
9806 struct CppType<VkIndirectCommandsLayoutNV, VK_NULL_HANDLE>
9807 {
9808 using Type = IndirectCommandsLayoutNV;
9809 };
9810 #endif
9811
9812 template <>
9813 struct isVulkanHandleType<IndirectCommandsLayoutNV>
9814 {
9815 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
9816 };
9817
9818 // wrapper class for handle VkIndirectExecutionSetEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectExecutionSetEXT.html
9819 class IndirectExecutionSetEXT
9820 {
9821 public:
9822 using CType = VkIndirectExecutionSetEXT;
9823 using NativeType = VkIndirectExecutionSetEXT;
9824
9825 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eIndirectExecutionSetEXT;
9826 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown;
9827
9828 public:
9829 IndirectExecutionSetEXT() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
9830
9831 IndirectExecutionSetEXT( IndirectExecutionSetEXT const & rhs ) = default;
9832 IndirectExecutionSetEXT & operator=( IndirectExecutionSetEXT const & rhs ) = default;
9833
9834 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
9835 IndirectExecutionSetEXT( IndirectExecutionSetEXT && rhs ) = default;
9836 IndirectExecutionSetEXT & operator=( IndirectExecutionSetEXT && rhs ) = default;
9837 #else
9838 IndirectExecutionSetEXT( IndirectExecutionSetEXT && rhs ) VULKAN_HPP_NOEXCEPT : m_indirectExecutionSetEXT( exchange( rhs.m_indirectExecutionSetEXT, {} ) )
9839 {
9840 }
9841
9842 IndirectExecutionSetEXT & operator=( IndirectExecutionSetEXT && rhs ) VULKAN_HPP_NOEXCEPT
9843 {
9844 m_indirectExecutionSetEXT = exchange( rhs.m_indirectExecutionSetEXT, {} );
9845 return *this;
9846 }
9847 #endif
9848
9849 VULKAN_HPP_CONSTEXPR IndirectExecutionSetEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
9850
9851 VULKAN_HPP_TYPESAFE_EXPLICIT IndirectExecutionSetEXT( VkIndirectExecutionSetEXT indirectExecutionSetEXT ) VULKAN_HPP_NOEXCEPT
9852 : m_indirectExecutionSetEXT( indirectExecutionSetEXT )
9853 {
9854 }
9855
9856 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
9857 IndirectExecutionSetEXT & operator=( VkIndirectExecutionSetEXT indirectExecutionSetEXT ) VULKAN_HPP_NOEXCEPT
9858 {
9859 m_indirectExecutionSetEXT = indirectExecutionSetEXT;
9860 return *this;
9861 }
9862 #endif
9863
9864 IndirectExecutionSetEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
9865 {
9866 m_indirectExecutionSetEXT = {};
9867 return *this;
9868 }
9869
9870 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkIndirectExecutionSetEXT() const VULKAN_HPP_NOEXCEPT
9871 {
9872 return m_indirectExecutionSetEXT;
9873 }
9874
9875 explicit operator bool() const VULKAN_HPP_NOEXCEPT
9876 {
9877 return m_indirectExecutionSetEXT != VK_NULL_HANDLE;
9878 }
9879
9880 bool operator!() const VULKAN_HPP_NOEXCEPT
9881 {
9882 return m_indirectExecutionSetEXT == VK_NULL_HANDLE;
9883 }
9884
9885 private:
9886 VkIndirectExecutionSetEXT m_indirectExecutionSetEXT = {};
9887 };
9888
9889 template <>
9890 struct CppType<ObjectType, ObjectType::eIndirectExecutionSetEXT>
9891 {
9892 using Type = IndirectExecutionSetEXT;
9893 };
9894
9895 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
9896 template <>
9897 struct CppType<VkIndirectExecutionSetEXT, VK_NULL_HANDLE>
9898 {
9899 using Type = IndirectExecutionSetEXT;
9900 };
9901 #endif
9902
9903 template <>
9904 struct isVulkanHandleType<IndirectExecutionSetEXT>
9905 {
9906 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
9907 };
9908
9909 // wrapper class for handle VkPrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPrivateDataSlot.html
9910 class PrivateDataSlot
9911 {
9912 public:
9913 using CType = VkPrivateDataSlot;
9914 using NativeType = VkPrivateDataSlot;
9915
9916 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePrivateDataSlot;
9917 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown;
9918
9919 public:
9920 PrivateDataSlot() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
9921
9922 PrivateDataSlot( PrivateDataSlot const & rhs ) = default;
9923 PrivateDataSlot & operator=( PrivateDataSlot const & rhs ) = default;
9924
9925 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
9926 PrivateDataSlot( PrivateDataSlot && rhs ) = default;
9927 PrivateDataSlot & operator=( PrivateDataSlot && rhs ) = default;
9928 #else
9929 PrivateDataSlot( PrivateDataSlot && rhs ) VULKAN_HPP_NOEXCEPT : m_privateDataSlot( exchange( rhs.m_privateDataSlot, {} ) ) {}
9930
9931 PrivateDataSlot & operator=( PrivateDataSlot && rhs ) VULKAN_HPP_NOEXCEPT
9932 {
9933 m_privateDataSlot = exchange( rhs.m_privateDataSlot, {} );
9934 return *this;
9935 }
9936 #endif
9937
9938 VULKAN_HPP_CONSTEXPR PrivateDataSlot( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
9939
9940 VULKAN_HPP_TYPESAFE_EXPLICIT PrivateDataSlot( VkPrivateDataSlot privateDataSlot ) VULKAN_HPP_NOEXCEPT : m_privateDataSlot( privateDataSlot ) {}
9941
9942 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
9943 PrivateDataSlot & operator=( VkPrivateDataSlot privateDataSlot ) VULKAN_HPP_NOEXCEPT
9944 {
9945 m_privateDataSlot = privateDataSlot;
9946 return *this;
9947 }
9948 #endif
9949
9950 PrivateDataSlot & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
9951 {
9952 m_privateDataSlot = {};
9953 return *this;
9954 }
9955
9956 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPrivateDataSlot() const VULKAN_HPP_NOEXCEPT
9957 {
9958 return m_privateDataSlot;
9959 }
9960
9961 explicit operator bool() const VULKAN_HPP_NOEXCEPT
9962 {
9963 return m_privateDataSlot != VK_NULL_HANDLE;
9964 }
9965
9966 bool operator!() const VULKAN_HPP_NOEXCEPT
9967 {
9968 return m_privateDataSlot == VK_NULL_HANDLE;
9969 }
9970
9971 private:
9972 VkPrivateDataSlot m_privateDataSlot = {};
9973 };
9974
9975 template <>
9976 struct CppType<ObjectType, ObjectType::ePrivateDataSlot>
9977 {
9978 using Type = PrivateDataSlot;
9979 };
9980
9981 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
9982 template <>
9983 struct CppType<VkPrivateDataSlot, VK_NULL_HANDLE>
9984 {
9985 using Type = PrivateDataSlot;
9986 };
9987 #endif
9988
9989 template <>
9990 struct isVulkanHandleType<PrivateDataSlot>
9991 {
9992 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
9993 };
9994
9995 using PrivateDataSlotEXT = PrivateDataSlot;
9996
9997 // wrapper class for handle VkRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderPass.html
9998 class RenderPass
9999 {
10000 public:
10001 using CType = VkRenderPass;
10002 using NativeType = VkRenderPass;
10003
10004 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eRenderPass;
10005 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eRenderPass;
10006
10007 public:
10008 RenderPass() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
10009
10010 RenderPass( RenderPass const & rhs ) = default;
10011 RenderPass & operator=( RenderPass const & rhs ) = default;
10012
10013 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
10014 RenderPass( RenderPass && rhs ) = default;
10015 RenderPass & operator=( RenderPass && rhs ) = default;
10016 #else
10017 RenderPass( RenderPass && rhs ) VULKAN_HPP_NOEXCEPT : m_renderPass( exchange( rhs.m_renderPass, {} ) ) {}
10018
10019 RenderPass & operator=( RenderPass && rhs ) VULKAN_HPP_NOEXCEPT
10020 {
10021 m_renderPass = exchange( rhs.m_renderPass, {} );
10022 return *this;
10023 }
10024 #endif
10025
10026 VULKAN_HPP_CONSTEXPR RenderPass( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
10027
10028 VULKAN_HPP_TYPESAFE_EXPLICIT RenderPass( VkRenderPass renderPass ) VULKAN_HPP_NOEXCEPT : m_renderPass( renderPass ) {}
10029
10030 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
10031 RenderPass & operator=( VkRenderPass renderPass ) VULKAN_HPP_NOEXCEPT
10032 {
10033 m_renderPass = renderPass;
10034 return *this;
10035 }
10036 #endif
10037
10038 RenderPass & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
10039 {
10040 m_renderPass = {};
10041 return *this;
10042 }
10043
10044 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkRenderPass() const VULKAN_HPP_NOEXCEPT
10045 {
10046 return m_renderPass;
10047 }
10048
10049 explicit operator bool() const VULKAN_HPP_NOEXCEPT
10050 {
10051 return m_renderPass != VK_NULL_HANDLE;
10052 }
10053
10054 bool operator!() const VULKAN_HPP_NOEXCEPT
10055 {
10056 return m_renderPass == VK_NULL_HANDLE;
10057 }
10058
10059 private:
10060 VkRenderPass m_renderPass = {};
10061 };
10062
10063 template <>
10064 struct CppType<ObjectType, ObjectType::eRenderPass>
10065 {
10066 using Type = RenderPass;
10067 };
10068
10069 template <>
10070 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eRenderPass>
10071 {
10072 using Type = RenderPass;
10073 };
10074
10075 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
10076 template <>
10077 struct CppType<VkRenderPass, VK_NULL_HANDLE>
10078 {
10079 using Type = RenderPass;
10080 };
10081 #endif
10082
10083 template <>
10084 struct isVulkanHandleType<RenderPass>
10085 {
10086 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
10087 };
10088
10089 // wrapper class for handle VkSampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSampler.html
10090 class Sampler
10091 {
10092 public:
10093 using CType = VkSampler;
10094 using NativeType = VkSampler;
10095
10096 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eSampler;
10097 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eSampler;
10098
10099 public:
10100 Sampler() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
10101
10102 Sampler( Sampler const & rhs ) = default;
10103 Sampler & operator=( Sampler const & rhs ) = default;
10104
10105 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
10106 Sampler( Sampler && rhs ) = default;
10107 Sampler & operator=( Sampler && rhs ) = default;
10108 #else
10109 Sampler( Sampler && rhs ) VULKAN_HPP_NOEXCEPT : m_sampler( exchange( rhs.m_sampler, {} ) ) {}
10110
10111 Sampler & operator=( Sampler && rhs ) VULKAN_HPP_NOEXCEPT
10112 {
10113 m_sampler = exchange( rhs.m_sampler, {} );
10114 return *this;
10115 }
10116 #endif
10117
10118 VULKAN_HPP_CONSTEXPR Sampler( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
10119
10120 VULKAN_HPP_TYPESAFE_EXPLICIT Sampler( VkSampler sampler ) VULKAN_HPP_NOEXCEPT : m_sampler( sampler ) {}
10121
10122 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
10123 Sampler & operator=( VkSampler sampler ) VULKAN_HPP_NOEXCEPT
10124 {
10125 m_sampler = sampler;
10126 return *this;
10127 }
10128 #endif
10129
10130 Sampler & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
10131 {
10132 m_sampler = {};
10133 return *this;
10134 }
10135
10136 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSampler() const VULKAN_HPP_NOEXCEPT
10137 {
10138 return m_sampler;
10139 }
10140
10141 explicit operator bool() const VULKAN_HPP_NOEXCEPT
10142 {
10143 return m_sampler != VK_NULL_HANDLE;
10144 }
10145
10146 bool operator!() const VULKAN_HPP_NOEXCEPT
10147 {
10148 return m_sampler == VK_NULL_HANDLE;
10149 }
10150
10151 private:
10152 VkSampler m_sampler = {};
10153 };
10154
10155 template <>
10156 struct CppType<ObjectType, ObjectType::eSampler>
10157 {
10158 using Type = Sampler;
10159 };
10160
10161 template <>
10162 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eSampler>
10163 {
10164 using Type = Sampler;
10165 };
10166
10167 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
10168 template <>
10169 struct CppType<VkSampler, VK_NULL_HANDLE>
10170 {
10171 using Type = Sampler;
10172 };
10173 #endif
10174
10175 template <>
10176 struct isVulkanHandleType<Sampler>
10177 {
10178 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
10179 };
10180
10181 // wrapper class for handle VkSamplerYcbcrConversion, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSamplerYcbcrConversion.html
10182 class SamplerYcbcrConversion
10183 {
10184 public:
10185 using CType = VkSamplerYcbcrConversion;
10186 using NativeType = VkSamplerYcbcrConversion;
10187
10188 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eSamplerYcbcrConversion;
10189 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eSamplerYcbcrConversion;
10190
10191 public:
10192 SamplerYcbcrConversion() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
10193
10194 SamplerYcbcrConversion( SamplerYcbcrConversion const & rhs ) = default;
10195 SamplerYcbcrConversion & operator=( SamplerYcbcrConversion const & rhs ) = default;
10196
10197 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
10198 SamplerYcbcrConversion( SamplerYcbcrConversion && rhs ) = default;
10199 SamplerYcbcrConversion & operator=( SamplerYcbcrConversion && rhs ) = default;
10200 #else
10201 SamplerYcbcrConversion( SamplerYcbcrConversion && rhs ) VULKAN_HPP_NOEXCEPT : m_samplerYcbcrConversion( exchange( rhs.m_samplerYcbcrConversion, {} ) ) {}
10202
10203 SamplerYcbcrConversion & operator=( SamplerYcbcrConversion && rhs ) VULKAN_HPP_NOEXCEPT
10204 {
10205 m_samplerYcbcrConversion = exchange( rhs.m_samplerYcbcrConversion, {} );
10206 return *this;
10207 }
10208 #endif
10209
10210 VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
10211
10212 VULKAN_HPP_TYPESAFE_EXPLICIT SamplerYcbcrConversion( VkSamplerYcbcrConversion samplerYcbcrConversion ) VULKAN_HPP_NOEXCEPT
10213 : m_samplerYcbcrConversion( samplerYcbcrConversion )
10214 {
10215 }
10216
10217 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
10218 SamplerYcbcrConversion & operator=( VkSamplerYcbcrConversion samplerYcbcrConversion ) VULKAN_HPP_NOEXCEPT
10219 {
10220 m_samplerYcbcrConversion = samplerYcbcrConversion;
10221 return *this;
10222 }
10223 #endif
10224
10225 SamplerYcbcrConversion & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
10226 {
10227 m_samplerYcbcrConversion = {};
10228 return *this;
10229 }
10230
10231 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSamplerYcbcrConversion() const VULKAN_HPP_NOEXCEPT
10232 {
10233 return m_samplerYcbcrConversion;
10234 }
10235
10236 explicit operator bool() const VULKAN_HPP_NOEXCEPT
10237 {
10238 return m_samplerYcbcrConversion != VK_NULL_HANDLE;
10239 }
10240
10241 bool operator!() const VULKAN_HPP_NOEXCEPT
10242 {
10243 return m_samplerYcbcrConversion == VK_NULL_HANDLE;
10244 }
10245
10246 private:
10247 VkSamplerYcbcrConversion m_samplerYcbcrConversion = {};
10248 };
10249
10250 template <>
10251 struct CppType<ObjectType, ObjectType::eSamplerYcbcrConversion>
10252 {
10253 using Type = SamplerYcbcrConversion;
10254 };
10255
10256 template <>
10257 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eSamplerYcbcrConversion>
10258 {
10259 using Type = SamplerYcbcrConversion;
10260 };
10261
10262 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
10263 template <>
10264 struct CppType<VkSamplerYcbcrConversion, VK_NULL_HANDLE>
10265 {
10266 using Type = SamplerYcbcrConversion;
10267 };
10268 #endif
10269
10270 template <>
10271 struct isVulkanHandleType<SamplerYcbcrConversion>
10272 {
10273 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
10274 };
10275
10276 using SamplerYcbcrConversionKHR = SamplerYcbcrConversion;
10277
10278 // wrapper class for handle VkShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderModule.html
10279 class ShaderModule
10280 {
10281 public:
10282 using CType = VkShaderModule;
10283 using NativeType = VkShaderModule;
10284
10285 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eShaderModule;
10286 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eShaderModule;
10287
10288 public:
10289 ShaderModule() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
10290
10291 ShaderModule( ShaderModule const & rhs ) = default;
10292 ShaderModule & operator=( ShaderModule const & rhs ) = default;
10293
10294 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
10295 ShaderModule( ShaderModule && rhs ) = default;
10296 ShaderModule & operator=( ShaderModule && rhs ) = default;
10297 #else
10298 ShaderModule( ShaderModule && rhs ) VULKAN_HPP_NOEXCEPT : m_shaderModule( exchange( rhs.m_shaderModule, {} ) ) {}
10299
10300 ShaderModule & operator=( ShaderModule && rhs ) VULKAN_HPP_NOEXCEPT
10301 {
10302 m_shaderModule = exchange( rhs.m_shaderModule, {} );
10303 return *this;
10304 }
10305 #endif
10306
10307 VULKAN_HPP_CONSTEXPR ShaderModule( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
10308
10309 VULKAN_HPP_TYPESAFE_EXPLICIT ShaderModule( VkShaderModule shaderModule ) VULKAN_HPP_NOEXCEPT : m_shaderModule( shaderModule ) {}
10310
10311 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
10312 ShaderModule & operator=( VkShaderModule shaderModule ) VULKAN_HPP_NOEXCEPT
10313 {
10314 m_shaderModule = shaderModule;
10315 return *this;
10316 }
10317 #endif
10318
10319 ShaderModule & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
10320 {
10321 m_shaderModule = {};
10322 return *this;
10323 }
10324
10325 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkShaderModule() const VULKAN_HPP_NOEXCEPT
10326 {
10327 return m_shaderModule;
10328 }
10329
10330 explicit operator bool() const VULKAN_HPP_NOEXCEPT
10331 {
10332 return m_shaderModule != VK_NULL_HANDLE;
10333 }
10334
10335 bool operator!() const VULKAN_HPP_NOEXCEPT
10336 {
10337 return m_shaderModule == VK_NULL_HANDLE;
10338 }
10339
10340 private:
10341 VkShaderModule m_shaderModule = {};
10342 };
10343
10344 template <>
10345 struct CppType<ObjectType, ObjectType::eShaderModule>
10346 {
10347 using Type = ShaderModule;
10348 };
10349
10350 template <>
10351 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eShaderModule>
10352 {
10353 using Type = ShaderModule;
10354 };
10355
10356 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
10357 template <>
10358 struct CppType<VkShaderModule, VK_NULL_HANDLE>
10359 {
10360 using Type = ShaderModule;
10361 };
10362 #endif
10363
10364 template <>
10365 struct isVulkanHandleType<ShaderModule>
10366 {
10367 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
10368 };
10369
10370 // wrapper class for handle VkTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTensorARM.html
10371 class TensorARM
10372 {
10373 public:
10374 using CType = VkTensorARM;
10375 using NativeType = VkTensorARM;
10376
10377 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eTensorARM;
10378 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown;
10379
10380 public:
10381 TensorARM() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
10382
10383 TensorARM( TensorARM const & rhs ) = default;
10384 TensorARM & operator=( TensorARM const & rhs ) = default;
10385
10386 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
10387 TensorARM( TensorARM && rhs ) = default;
10388 TensorARM & operator=( TensorARM && rhs ) = default;
10389 #else
10390 TensorARM( TensorARM && rhs ) VULKAN_HPP_NOEXCEPT : m_tensorARM( exchange( rhs.m_tensorARM, {} ) ) {}
10391
10392 TensorARM & operator=( TensorARM && rhs ) VULKAN_HPP_NOEXCEPT
10393 {
10394 m_tensorARM = exchange( rhs.m_tensorARM, {} );
10395 return *this;
10396 }
10397 #endif
10398
10399 VULKAN_HPP_CONSTEXPR TensorARM( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
10400
10401 VULKAN_HPP_TYPESAFE_EXPLICIT TensorARM( VkTensorARM tensorARM ) VULKAN_HPP_NOEXCEPT : m_tensorARM( tensorARM ) {}
10402
10403 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
10404 TensorARM & operator=( VkTensorARM tensorARM ) VULKAN_HPP_NOEXCEPT
10405 {
10406 m_tensorARM = tensorARM;
10407 return *this;
10408 }
10409 #endif
10410
10411 TensorARM & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
10412 {
10413 m_tensorARM = {};
10414 return *this;
10415 }
10416
10417 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkTensorARM() const VULKAN_HPP_NOEXCEPT
10418 {
10419 return m_tensorARM;
10420 }
10421
10422 explicit operator bool() const VULKAN_HPP_NOEXCEPT
10423 {
10424 return m_tensorARM != VK_NULL_HANDLE;
10425 }
10426
10427 bool operator!() const VULKAN_HPP_NOEXCEPT
10428 {
10429 return m_tensorARM == VK_NULL_HANDLE;
10430 }
10431
10432 private:
10433 VkTensorARM m_tensorARM = {};
10434 };
10435
10436 template <>
10437 struct CppType<ObjectType, ObjectType::eTensorARM>
10438 {
10439 using Type = TensorARM;
10440 };
10441
10442 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
10443 template <>
10444 struct CppType<VkTensorARM, VK_NULL_HANDLE>
10445 {
10446 using Type = TensorARM;
10447 };
10448 #endif
10449
10450 template <>
10451 struct isVulkanHandleType<TensorARM>
10452 {
10453 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
10454 };
10455
10456 // wrapper class for handle VkTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTensorViewARM.html
10457 class TensorViewARM
10458 {
10459 public:
10460 using CType = VkTensorViewARM;
10461 using NativeType = VkTensorViewARM;
10462
10463 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eTensorViewARM;
10464 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown;
10465
10466 public:
10467 TensorViewARM() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
10468
10469 TensorViewARM( TensorViewARM const & rhs ) = default;
10470 TensorViewARM & operator=( TensorViewARM const & rhs ) = default;
10471
10472 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
10473 TensorViewARM( TensorViewARM && rhs ) = default;
10474 TensorViewARM & operator=( TensorViewARM && rhs ) = default;
10475 #else
10476 TensorViewARM( TensorViewARM && rhs ) VULKAN_HPP_NOEXCEPT : m_tensorViewARM( exchange( rhs.m_tensorViewARM, {} ) ) {}
10477
10478 TensorViewARM & operator=( TensorViewARM && rhs ) VULKAN_HPP_NOEXCEPT
10479 {
10480 m_tensorViewARM = exchange( rhs.m_tensorViewARM, {} );
10481 return *this;
10482 }
10483 #endif
10484
10485 VULKAN_HPP_CONSTEXPR TensorViewARM( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
10486
10487 VULKAN_HPP_TYPESAFE_EXPLICIT TensorViewARM( VkTensorViewARM tensorViewARM ) VULKAN_HPP_NOEXCEPT : m_tensorViewARM( tensorViewARM ) {}
10488
10489 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
10490 TensorViewARM & operator=( VkTensorViewARM tensorViewARM ) VULKAN_HPP_NOEXCEPT
10491 {
10492 m_tensorViewARM = tensorViewARM;
10493 return *this;
10494 }
10495 #endif
10496
10497 TensorViewARM & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
10498 {
10499 m_tensorViewARM = {};
10500 return *this;
10501 }
10502
10503 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkTensorViewARM() const VULKAN_HPP_NOEXCEPT
10504 {
10505 return m_tensorViewARM;
10506 }
10507
10508 explicit operator bool() const VULKAN_HPP_NOEXCEPT
10509 {
10510 return m_tensorViewARM != VK_NULL_HANDLE;
10511 }
10512
10513 bool operator!() const VULKAN_HPP_NOEXCEPT
10514 {
10515 return m_tensorViewARM == VK_NULL_HANDLE;
10516 }
10517
10518 private:
10519 VkTensorViewARM m_tensorViewARM = {};
10520 };
10521
10522 template <>
10523 struct CppType<ObjectType, ObjectType::eTensorViewARM>
10524 {
10525 using Type = TensorViewARM;
10526 };
10527
10528 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
10529 template <>
10530 struct CppType<VkTensorViewARM, VK_NULL_HANDLE>
10531 {
10532 using Type = TensorViewARM;
10533 };
10534 #endif
10535
10536 template <>
10537 struct isVulkanHandleType<TensorViewARM>
10538 {
10539 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
10540 };
10541
10542 // wrapper class for handle VkValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkValidationCacheEXT.html
10543 class ValidationCacheEXT
10544 {
10545 public:
10546 using CType = VkValidationCacheEXT;
10547 using NativeType = VkValidationCacheEXT;
10548
10549 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eValidationCacheEXT;
10550 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eValidationCacheEXT;
10551
10552 public:
10553 ValidationCacheEXT() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
10554
10555 ValidationCacheEXT( ValidationCacheEXT const & rhs ) = default;
10556 ValidationCacheEXT & operator=( ValidationCacheEXT const & rhs ) = default;
10557
10558 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
10559 ValidationCacheEXT( ValidationCacheEXT && rhs ) = default;
10560 ValidationCacheEXT & operator=( ValidationCacheEXT && rhs ) = default;
10561 #else
10562 ValidationCacheEXT( ValidationCacheEXT && rhs ) VULKAN_HPP_NOEXCEPT : m_validationCacheEXT( exchange( rhs.m_validationCacheEXT, {} ) ) {}
10563
10564 ValidationCacheEXT & operator=( ValidationCacheEXT && rhs ) VULKAN_HPP_NOEXCEPT
10565 {
10566 m_validationCacheEXT = exchange( rhs.m_validationCacheEXT, {} );
10567 return *this;
10568 }
10569 #endif
10570
10571 VULKAN_HPP_CONSTEXPR ValidationCacheEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
10572
10573 VULKAN_HPP_TYPESAFE_EXPLICIT ValidationCacheEXT( VkValidationCacheEXT validationCacheEXT ) VULKAN_HPP_NOEXCEPT : m_validationCacheEXT( validationCacheEXT )
10574 {
10575 }
10576
10577 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
10578 ValidationCacheEXT & operator=( VkValidationCacheEXT validationCacheEXT ) VULKAN_HPP_NOEXCEPT
10579 {
10580 m_validationCacheEXT = validationCacheEXT;
10581 return *this;
10582 }
10583 #endif
10584
10585 ValidationCacheEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
10586 {
10587 m_validationCacheEXT = {};
10588 return *this;
10589 }
10590
10591 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkValidationCacheEXT() const VULKAN_HPP_NOEXCEPT
10592 {
10593 return m_validationCacheEXT;
10594 }
10595
10596 explicit operator bool() const VULKAN_HPP_NOEXCEPT
10597 {
10598 return m_validationCacheEXT != VK_NULL_HANDLE;
10599 }
10600
10601 bool operator!() const VULKAN_HPP_NOEXCEPT
10602 {
10603 return m_validationCacheEXT == VK_NULL_HANDLE;
10604 }
10605
10606 private:
10607 VkValidationCacheEXT m_validationCacheEXT = {};
10608 };
10609
10610 template <>
10611 struct CppType<ObjectType, ObjectType::eValidationCacheEXT>
10612 {
10613 using Type = ValidationCacheEXT;
10614 };
10615
10616 template <>
10617 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eValidationCacheEXT>
10618 {
10619 using Type = ValidationCacheEXT;
10620 };
10621
10622 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
10623 template <>
10624 struct CppType<VkValidationCacheEXT, VK_NULL_HANDLE>
10625 {
10626 using Type = ValidationCacheEXT;
10627 };
10628 #endif
10629
10630 template <>
10631 struct isVulkanHandleType<ValidationCacheEXT>
10632 {
10633 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
10634 };
10635
10636 // wrapper class for handle VkVideoSessionParametersKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoSessionParametersKHR.html
10637 class VideoSessionParametersKHR
10638 {
10639 public:
10640 using CType = VkVideoSessionParametersKHR;
10641 using NativeType = VkVideoSessionParametersKHR;
10642
10643 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eVideoSessionParametersKHR;
10644 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown;
10645
10646 public:
10647 VideoSessionParametersKHR() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
10648
10649 VideoSessionParametersKHR( VideoSessionParametersKHR const & rhs ) = default;
10650 VideoSessionParametersKHR & operator=( VideoSessionParametersKHR const & rhs ) = default;
10651
10652 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
10653 VideoSessionParametersKHR( VideoSessionParametersKHR && rhs ) = default;
10654 VideoSessionParametersKHR & operator=( VideoSessionParametersKHR && rhs ) = default;
10655 #else
10656 VideoSessionParametersKHR( VideoSessionParametersKHR && rhs ) VULKAN_HPP_NOEXCEPT
10657 : m_videoSessionParametersKHR( exchange( rhs.m_videoSessionParametersKHR, {} ) )
10658 {
10659 }
10660
10661 VideoSessionParametersKHR & operator=( VideoSessionParametersKHR && rhs ) VULKAN_HPP_NOEXCEPT
10662 {
10663 m_videoSessionParametersKHR = exchange( rhs.m_videoSessionParametersKHR, {} );
10664 return *this;
10665 }
10666 #endif
10667
10668 VULKAN_HPP_CONSTEXPR VideoSessionParametersKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
10669
10670 VULKAN_HPP_TYPESAFE_EXPLICIT VideoSessionParametersKHR( VkVideoSessionParametersKHR videoSessionParametersKHR ) VULKAN_HPP_NOEXCEPT
10671 : m_videoSessionParametersKHR( videoSessionParametersKHR )
10672 {
10673 }
10674
10675 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
10676 VideoSessionParametersKHR & operator=( VkVideoSessionParametersKHR videoSessionParametersKHR ) VULKAN_HPP_NOEXCEPT
10677 {
10678 m_videoSessionParametersKHR = videoSessionParametersKHR;
10679 return *this;
10680 }
10681 #endif
10682
10683 VideoSessionParametersKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
10684 {
10685 m_videoSessionParametersKHR = {};
10686 return *this;
10687 }
10688
10689 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkVideoSessionParametersKHR() const VULKAN_HPP_NOEXCEPT
10690 {
10691 return m_videoSessionParametersKHR;
10692 }
10693
10694 explicit operator bool() const VULKAN_HPP_NOEXCEPT
10695 {
10696 return m_videoSessionParametersKHR != VK_NULL_HANDLE;
10697 }
10698
10699 bool operator!() const VULKAN_HPP_NOEXCEPT
10700 {
10701 return m_videoSessionParametersKHR == VK_NULL_HANDLE;
10702 }
10703
10704 private:
10705 VkVideoSessionParametersKHR m_videoSessionParametersKHR = {};
10706 };
10707
10708 template <>
10709 struct CppType<ObjectType, ObjectType::eVideoSessionParametersKHR>
10710 {
10711 using Type = VideoSessionParametersKHR;
10712 };
10713
10714 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
10715 template <>
10716 struct CppType<VkVideoSessionParametersKHR, VK_NULL_HANDLE>
10717 {
10718 using Type = VideoSessionParametersKHR;
10719 };
10720 #endif
10721
10722 template <>
10723 struct isVulkanHandleType<VideoSessionParametersKHR>
10724 {
10725 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
10726 };
10727
10728 // wrapper class for handle VkPipelineBinaryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineBinaryKHR.html
10729 class PipelineBinaryKHR
10730 {
10731 public:
10732 using CType = VkPipelineBinaryKHR;
10733 using NativeType = VkPipelineBinaryKHR;
10734
10735 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePipelineBinaryKHR;
10736 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown;
10737
10738 public:
10739 PipelineBinaryKHR() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
10740
10741 PipelineBinaryKHR( PipelineBinaryKHR const & rhs ) = default;
10742 PipelineBinaryKHR & operator=( PipelineBinaryKHR const & rhs ) = default;
10743
10744 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
10745 PipelineBinaryKHR( PipelineBinaryKHR && rhs ) = default;
10746 PipelineBinaryKHR & operator=( PipelineBinaryKHR && rhs ) = default;
10747 #else
10748 PipelineBinaryKHR( PipelineBinaryKHR && rhs ) VULKAN_HPP_NOEXCEPT : m_pipelineBinaryKHR( exchange( rhs.m_pipelineBinaryKHR, {} ) ) {}
10749
10750 PipelineBinaryKHR & operator=( PipelineBinaryKHR && rhs ) VULKAN_HPP_NOEXCEPT
10751 {
10752 m_pipelineBinaryKHR = exchange( rhs.m_pipelineBinaryKHR, {} );
10753 return *this;
10754 }
10755 #endif
10756
10757 VULKAN_HPP_CONSTEXPR PipelineBinaryKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
10758
10759 VULKAN_HPP_TYPESAFE_EXPLICIT PipelineBinaryKHR( VkPipelineBinaryKHR pipelineBinaryKHR ) VULKAN_HPP_NOEXCEPT : m_pipelineBinaryKHR( pipelineBinaryKHR ) {}
10760
10761 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
10762 PipelineBinaryKHR & operator=( VkPipelineBinaryKHR pipelineBinaryKHR ) VULKAN_HPP_NOEXCEPT
10763 {
10764 m_pipelineBinaryKHR = pipelineBinaryKHR;
10765 return *this;
10766 }
10767 #endif
10768
10769 PipelineBinaryKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
10770 {
10771 m_pipelineBinaryKHR = {};
10772 return *this;
10773 }
10774
10775 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineBinaryKHR() const VULKAN_HPP_NOEXCEPT
10776 {
10777 return m_pipelineBinaryKHR;
10778 }
10779
10780 explicit operator bool() const VULKAN_HPP_NOEXCEPT
10781 {
10782 return m_pipelineBinaryKHR != VK_NULL_HANDLE;
10783 }
10784
10785 bool operator!() const VULKAN_HPP_NOEXCEPT
10786 {
10787 return m_pipelineBinaryKHR == VK_NULL_HANDLE;
10788 }
10789
10790 private:
10791 VkPipelineBinaryKHR m_pipelineBinaryKHR = {};
10792 };
10793
10794 template <>
10795 struct CppType<ObjectType, ObjectType::ePipelineBinaryKHR>
10796 {
10797 using Type = PipelineBinaryKHR;
10798 };
10799
10800 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
10801 template <>
10802 struct CppType<VkPipelineBinaryKHR, VK_NULL_HANDLE>
10803 {
10804 using Type = PipelineBinaryKHR;
10805 };
10806 #endif
10807
10808 template <>
10809 struct isVulkanHandleType<PipelineBinaryKHR>
10810 {
10811 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
10812 };
10813
10814 // wrapper class for handle VkQueue, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueue.html
10815 class Queue
10816 {
10817 public:
10818 using CType = VkQueue;
10819 using NativeType = VkQueue;
10820
10821 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eQueue;
10822 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eQueue;
10823
10824 public:
10825 Queue() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
10826
10827 Queue( Queue const & rhs ) = default;
10828 Queue & operator=( Queue const & rhs ) = default;
10829
10830 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
10831 Queue( Queue && rhs ) = default;
10832 Queue & operator=( Queue && rhs ) = default;
10833 #else
10834 Queue( Queue && rhs ) VULKAN_HPP_NOEXCEPT : m_queue( exchange( rhs.m_queue, {} ) ) {}
10835
10836 Queue & operator=( Queue && rhs ) VULKAN_HPP_NOEXCEPT
10837 {
10838 m_queue = exchange( rhs.m_queue, {} );
10839 return *this;
10840 }
10841 #endif
10842
10843 VULKAN_HPP_CONSTEXPR Queue( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
10844
10845 Queue( VkQueue queue ) VULKAN_HPP_NOEXCEPT : m_queue( queue ) {}
10846
10847 Queue & operator=( VkQueue queue ) VULKAN_HPP_NOEXCEPT
10848 {
10849 m_queue = queue;
10850 return *this;
10851 }
10852
10853 Queue & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
10854 {
10855 m_queue = {};
10856 return *this;
10857 }
10858
10859 //=== VK_VERSION_1_0 ===
10860
10861 // wrapper function for command vkQueueSubmit, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSubmit.html
10862 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
10863 VULKAN_HPP_NODISCARD Result submit( uint32_t submitCount,
10864 const SubmitInfo * pSubmits,
10865 Fence fence,
10866 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10867 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10868 // wrapper function for command vkQueueSubmit, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSubmit.html
10869 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
10870 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type submit( ArrayProxy<const SubmitInfo> const & submits,
10871 Fence fence VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
10872 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10873 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10874
10875 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
10876 // wrapper function for command vkQueueWaitIdle, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueWaitIdle.html
10877 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
10878 VULKAN_HPP_NODISCARD Result waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10879 #else
10880 // wrapper function for command vkQueueWaitIdle, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueWaitIdle.html
10881 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
10882 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10883 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10884
10885 // wrapper function for command vkQueueBindSparse, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueBindSparse.html
10886 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
10887 VULKAN_HPP_NODISCARD Result bindSparse( uint32_t bindInfoCount,
10888 const BindSparseInfo * pBindInfo,
10889 Fence fence,
10890 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10891 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10892 // wrapper function for command vkQueueBindSparse, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueBindSparse.html
10893 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
10894 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
10895 bindSparse( ArrayProxy<const BindSparseInfo> const & bindInfo,
10896 Fence fence VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
10897 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10898 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10899
10900 //=== VK_VERSION_1_3 ===
10901
10902 // wrapper function for command vkQueueSubmit2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSubmit2.html
10903 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
10904 VULKAN_HPP_NODISCARD Result submit2( uint32_t submitCount,
10905 const SubmitInfo2 * pSubmits,
10906 Fence fence,
10907 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10908 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10909 // wrapper function for command vkQueueSubmit2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSubmit2.html
10910 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
10911 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type submit2( ArrayProxy<const SubmitInfo2> const & submits,
10912 Fence fence VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
10913 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10914 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10915
10916 //=== VK_KHR_swapchain ===
10917
10918 // wrapper function for command vkQueuePresentKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueuePresentKHR.html
10919 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
10920 VULKAN_HPP_NODISCARD Result presentKHR( const PresentInfoKHR * pPresentInfo,
10921 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10922 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10923 // wrapper function for command vkQueuePresentKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueuePresentKHR.html
10924 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
10925 VULKAN_HPP_NODISCARD Result presentKHR( const PresentInfoKHR & presentInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10926 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10927
10928 //=== VK_EXT_debug_utils ===
10929
10930 // wrapper function for command vkQueueBeginDebugUtilsLabelEXT, see
10931 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueBeginDebugUtilsLabelEXT.html
10932 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
10933 void beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT * pLabelInfo,
10934 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10935 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10936 // wrapper function for command vkQueueBeginDebugUtilsLabelEXT, see
10937 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueBeginDebugUtilsLabelEXT.html
10938 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
10939 void beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10940 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10941
10942 // wrapper function for command vkQueueEndDebugUtilsLabelEXT, see
10943 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueEndDebugUtilsLabelEXT.html
10944 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
10945 void endDebugUtilsLabelEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10946
10947 // wrapper function for command vkQueueInsertDebugUtilsLabelEXT, see
10948 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueInsertDebugUtilsLabelEXT.html
10949 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
10950 void insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT * pLabelInfo,
10951 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10952 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10953 // wrapper function for command vkQueueInsertDebugUtilsLabelEXT, see
10954 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueInsertDebugUtilsLabelEXT.html
10955 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
10956 void insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo,
10957 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10958 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10959
10960 //=== VK_NV_device_diagnostic_checkpoints ===
10961
10962 // wrapper function for command vkGetQueueCheckpointDataNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueueCheckpointDataNV.html
10963 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
10964 void getCheckpointDataNV( uint32_t * pCheckpointDataCount,
10965 CheckpointDataNV * pCheckpointData,
10966 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10967 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10968 // wrapper function for command vkGetQueueCheckpointDataNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueueCheckpointDataNV.html
10969 template <typename CheckpointDataNVAllocator = std::allocator<CheckpointDataNV>,
10970 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10971 typename std::enable_if<std::is_same<typename CheckpointDataNVAllocator::value_type, CheckpointDataNV>::value, int>::type = 0,
10972 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
10973 VULKAN_HPP_NODISCARD std::vector<CheckpointDataNV, CheckpointDataNVAllocator>
10974 getCheckpointDataNV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10975 // wrapper function for command vkGetQueueCheckpointDataNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueueCheckpointDataNV.html
10976 template <typename CheckpointDataNVAllocator = std::allocator<CheckpointDataNV>,
10977 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10978 typename std::enable_if<std::is_same<typename CheckpointDataNVAllocator::value_type, CheckpointDataNV>::value, int>::type = 0,
10979 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
10980 VULKAN_HPP_NODISCARD std::vector<CheckpointDataNV, CheckpointDataNVAllocator>
10981 getCheckpointDataNV( CheckpointDataNVAllocator & checkpointDataNVAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10982 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10983
10984 // wrapper function for command vkGetQueueCheckpointData2NV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueueCheckpointData2NV.html
10985 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
10986 void getCheckpointData2NV( uint32_t * pCheckpointDataCount,
10987 CheckpointData2NV * pCheckpointData,
10988 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10989 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10990 // wrapper function for command vkGetQueueCheckpointData2NV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueueCheckpointData2NV.html
10991 template <typename CheckpointData2NVAllocator = std::allocator<CheckpointData2NV>,
10992 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10993 typename std::enable_if<std::is_same<typename CheckpointData2NVAllocator::value_type, CheckpointData2NV>::value, int>::type = 0,
10994 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
10995 VULKAN_HPP_NODISCARD std::vector<CheckpointData2NV, CheckpointData2NVAllocator>
10996 getCheckpointData2NV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10997 // wrapper function for command vkGetQueueCheckpointData2NV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueueCheckpointData2NV.html
10998 template <typename CheckpointData2NVAllocator = std::allocator<CheckpointData2NV>,
10999 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11000 typename std::enable_if<std::is_same<typename CheckpointData2NVAllocator::value_type, CheckpointData2NV>::value, int>::type = 0,
11001 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11002 VULKAN_HPP_NODISCARD std::vector<CheckpointData2NV, CheckpointData2NVAllocator>
11003 getCheckpointData2NV( CheckpointData2NVAllocator & checkpointData2NVAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11004 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11005
11006 //=== VK_INTEL_performance_query ===
11007
11008 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
11009 // wrapper function for command vkQueueSetPerformanceConfigurationINTEL, see
11010 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSetPerformanceConfigurationINTEL.html
11011 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11012 VULKAN_HPP_NODISCARD Result setPerformanceConfigurationINTEL( PerformanceConfigurationINTEL configuration,
11013 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11014 #else
11015 // wrapper function for command vkQueueSetPerformanceConfigurationINTEL, see
11016 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSetPerformanceConfigurationINTEL.html
11017 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11018 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
11019 setPerformanceConfigurationINTEL( PerformanceConfigurationINTEL configuration, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11020 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11021
11022 //=== VK_KHR_synchronization2 ===
11023
11024 // wrapper function for command vkQueueSubmit2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSubmit2KHR.html
11025 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11026 VULKAN_HPP_NODISCARD Result submit2KHR( uint32_t submitCount,
11027 const SubmitInfo2 * pSubmits,
11028 Fence fence,
11029 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11030 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11031 // wrapper function for command vkQueueSubmit2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSubmit2KHR.html
11032 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11033 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
11034 submit2KHR( ArrayProxy<const SubmitInfo2> const & submits,
11035 Fence fence VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
11036 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11037 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11038
11039 //=== VK_NV_low_latency2 ===
11040
11041 // wrapper function for command vkQueueNotifyOutOfBandNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueNotifyOutOfBandNV.html
11042 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11043 void notifyOutOfBandNV( const OutOfBandQueueTypeInfoNV * pQueueTypeInfo,
11044 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11045 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11046 // wrapper function for command vkQueueNotifyOutOfBandNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueNotifyOutOfBandNV.html
11047 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11048 void notifyOutOfBandNV( const OutOfBandQueueTypeInfoNV & queueTypeInfo,
11049 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11050 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11051
11052 #if defined( VK_USE_PLATFORM_OHOS )
11053 //=== VK_OHOS_native_buffer ===
11054
11055 // wrapper function for command vkQueueSignalReleaseImageOHOS, see
11056 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSignalReleaseImageOHOS.html
11057 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11058 VULKAN_HPP_NODISCARD Result signalReleaseImageOHOS( uint32_t waitSemaphoreCount,
11059 const Semaphore * pWaitSemaphores,
11060 Image image,
11061 int32_t * pNativeFenceFd,
11062 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11063 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11064 // wrapper function for command vkQueueSignalReleaseImageOHOS, see
11065 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSignalReleaseImageOHOS.html
11066 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11067 VULKAN_HPP_NODISCARD typename ResultValueType<int32_t>::type signalReleaseImageOHOS( ArrayProxy<const Semaphore> const & waitSemaphores,
11068 Image image,
11069 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11070 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11071 #endif /*VK_USE_PLATFORM_OHOS*/
11072
11073 operator VkQueue() const VULKAN_HPP_NOEXCEPT
11074 {
11075 return m_queue;
11076 }
11077
11078 explicit operator bool() const VULKAN_HPP_NOEXCEPT
11079 {
11080 return m_queue != VK_NULL_HANDLE;
11081 }
11082
11083 bool operator!() const VULKAN_HPP_NOEXCEPT
11084 {
11085 return m_queue == VK_NULL_HANDLE;
11086 }
11087
11088 private:
11089 VkQueue m_queue = {};
11090 };
11091
11092 template <>
11093 struct CppType<ObjectType, ObjectType::eQueue>
11094 {
11095 using Type = Queue;
11096 };
11097
11098 template <>
11099 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eQueue>
11100 {
11101 using Type = Queue;
11102 };
11103
11104 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
11105 template <>
11106 struct CppType<VkQueue, VK_NULL_HANDLE>
11107 {
11108 using Type = Queue;
11109 };
11110 #endif
11111
11112 template <>
11113 struct isVulkanHandleType<Queue>
11114 {
11115 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
11116 };
11117
11118 // wrapper class for handle VkDevice, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDevice.html
11119 class Device
11120 {
11121 public:
11122 using CType = VkDevice;
11123 using NativeType = VkDevice;
11124
11125 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDevice;
11126 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eDevice;
11127
11128 public:
11129 Device() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
11130
11131 Device( Device const & rhs ) = default;
11132 Device & operator=( Device const & rhs ) = default;
11133
11134 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
11135 Device( Device && rhs ) = default;
11136 Device & operator=( Device && rhs ) = default;
11137 #else
11138 Device( Device && rhs ) VULKAN_HPP_NOEXCEPT : m_device( exchange( rhs.m_device, {} ) ) {}
11139
11140 Device & operator=( Device && rhs ) VULKAN_HPP_NOEXCEPT
11141 {
11142 m_device = exchange( rhs.m_device, {} );
11143 return *this;
11144 }
11145 #endif
11146
11147 VULKAN_HPP_CONSTEXPR Device( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
11148
11149 Device( VkDevice device ) VULKAN_HPP_NOEXCEPT : m_device( device ) {}
11150
11151 Device & operator=( VkDevice device ) VULKAN_HPP_NOEXCEPT
11152 {
11153 m_device = device;
11154 return *this;
11155 }
11156
11157 Device & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
11158 {
11159 m_device = {};
11160 return *this;
11161 }
11162
11163 //=== VK_VERSION_1_0 ===
11164
11165 // wrapper function for command vkGetDeviceProcAddr, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceProcAddr.html
11166 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11167 PFN_vkVoidFunction getProcAddr( const char * pName, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11168 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11169 // wrapper function for command vkGetDeviceProcAddr, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceProcAddr.html
11170 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11171 PFN_VoidFunction getProcAddr( const std::string & name, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11172 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11173
11174 // wrapper function for command vkDestroyDevice, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDevice.html
11175 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11176 void destroy( const AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11177 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11178 // wrapper function for command vkDestroyDevice, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDevice.html
11179 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11180 void destroy( Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
11181 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11182 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11183
11184 // wrapper function for command vkGetDeviceQueue, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceQueue.html
11185 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11186 void getQueue( uint32_t queueFamilyIndex,
11187 uint32_t queueIndex,
11188 Queue * pQueue,
11189 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11190 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11191 // wrapper function for command vkGetDeviceQueue, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceQueue.html
11192 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11193 VULKAN_HPP_NODISCARD Queue getQueue( uint32_t queueFamilyIndex,
11194 uint32_t queueIndex,
11195 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11196 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11197
11198 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
11199 // wrapper function for command vkDeviceWaitIdle, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDeviceWaitIdle.html
11200 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11201 VULKAN_HPP_NODISCARD Result waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11202 #else
11203 // wrapper function for command vkDeviceWaitIdle, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDeviceWaitIdle.html
11204 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11205 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11206 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11207
11208 // wrapper function for command vkAllocateMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateMemory.html
11209 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11210 VULKAN_HPP_NODISCARD Result allocateMemory( const MemoryAllocateInfo * pAllocateInfo,
11211 const AllocationCallbacks * pAllocator,
11212 DeviceMemory * pMemory,
11213 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11214 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11215 // wrapper function for command vkAllocateMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateMemory.html
11216 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11217 VULKAN_HPP_NODISCARD typename ResultValueType<DeviceMemory>::type
11218 allocateMemory( const MemoryAllocateInfo & allocateInfo,
11219 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
11220 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11221 # ifndef VULKAN_HPP_NO_SMART_HANDLE
11222 // wrapper function for command vkAllocateMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateMemory.html
11223 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11224 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<DeviceMemory, Dispatch>>::type
11225 allocateMemoryUnique( const MemoryAllocateInfo & allocateInfo,
11226 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
11227 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11228 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
11229 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11230
11231 // wrapper function for command vkFreeMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeMemory.html
11232 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11233 void freeMemory( DeviceMemory memory,
11234 const AllocationCallbacks * pAllocator,
11235 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11236 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11237 // wrapper function for command vkFreeMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeMemory.html
11238 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11239 void freeMemory( DeviceMemory memory VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
11240 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
11241 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11242 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11243
11244 // wrapper function for command vkFreeMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeMemory.html
11245 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11246 void( free )( DeviceMemory memory,
11247 const AllocationCallbacks * pAllocator,
11248 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11249 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11250 // wrapper function for command vkFreeMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeMemory.html
11251 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11252 void( free )( DeviceMemory memory,
11253 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
11254 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11255 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11256
11257 // wrapper function for command vkMapMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMapMemory.html
11258 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11259 VULKAN_HPP_NODISCARD Result mapMemory( DeviceMemory memory,
11260 DeviceSize offset,
11261 DeviceSize size,
11262 MemoryMapFlags flags,
11263 void ** ppData,
11264 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11265 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11266 // wrapper function for command vkMapMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMapMemory.html
11267 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11268 VULKAN_HPP_NODISCARD typename ResultValueType<void *>::type mapMemory( DeviceMemory memory,
11269 DeviceSize offset,
11270 DeviceSize size,
11271 MemoryMapFlags flags VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
11272 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11273 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11274
11275 // wrapper function for command vkUnmapMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnmapMemory.html
11276 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11277 void unmapMemory( DeviceMemory memory, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11278
11279 // wrapper function for command vkFlushMappedMemoryRanges, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFlushMappedMemoryRanges.html
11280 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11281 VULKAN_HPP_NODISCARD Result flushMappedMemoryRanges( uint32_t memoryRangeCount,
11282 const MappedMemoryRange * pMemoryRanges,
11283 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11284 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11285 // wrapper function for command vkFlushMappedMemoryRanges, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFlushMappedMemoryRanges.html
11286 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11287 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
11288 flushMappedMemoryRanges( ArrayProxy<const MappedMemoryRange> const & memoryRanges, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11289 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11290
11291 // wrapper function for command vkInvalidateMappedMemoryRanges, see
11292 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkInvalidateMappedMemoryRanges.html
11293 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11294 VULKAN_HPP_NODISCARD Result invalidateMappedMemoryRanges( uint32_t memoryRangeCount,
11295 const MappedMemoryRange * pMemoryRanges,
11296 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11297 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11298 // wrapper function for command vkInvalidateMappedMemoryRanges, see
11299 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkInvalidateMappedMemoryRanges.html
11300 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11301 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
11302 invalidateMappedMemoryRanges( ArrayProxy<const MappedMemoryRange> const & memoryRanges,
11303 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11304 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11305
11306 // wrapper function for command vkGetDeviceMemoryCommitment, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMemoryCommitment.html
11307 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11308 void getMemoryCommitment( DeviceMemory memory,
11309 DeviceSize * pCommittedMemoryInBytes,
11310 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11311 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11312 // wrapper function for command vkGetDeviceMemoryCommitment, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMemoryCommitment.html
11313 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11314 VULKAN_HPP_NODISCARD DeviceSize getMemoryCommitment( DeviceMemory memory,
11315 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11316 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11317
11318 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
11319 // wrapper function for command vkBindBufferMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindBufferMemory.html
11320 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11321 VULKAN_HPP_NODISCARD Result bindBufferMemory( Buffer buffer,
11322 DeviceMemory memory,
11323 DeviceSize memoryOffset,
11324 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11325 #else
11326 // wrapper function for command vkBindBufferMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindBufferMemory.html
11327 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11328 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
11329 bindBufferMemory( Buffer buffer, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11330 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11331
11332 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
11333 // wrapper function for command vkBindImageMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindImageMemory.html
11334 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11335 VULKAN_HPP_NODISCARD Result bindImageMemory( Image image,
11336 DeviceMemory memory,
11337 DeviceSize memoryOffset,
11338 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11339 #else
11340 // wrapper function for command vkBindImageMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindImageMemory.html
11341 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11342 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
11343 bindImageMemory( Image image, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11344 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11345
11346 // wrapper function for command vkGetBufferMemoryRequirements, see
11347 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements.html
11348 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11349 void getBufferMemoryRequirements( Buffer buffer,
11350 MemoryRequirements * pMemoryRequirements,
11351 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11352 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11353 // wrapper function for command vkGetBufferMemoryRequirements, see
11354 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements.html
11355 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11356 VULKAN_HPP_NODISCARD MemoryRequirements
11357 getBufferMemoryRequirements( Buffer buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11358 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11359
11360 // wrapper function for command vkGetImageMemoryRequirements, see
11361 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements.html
11362 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11363 void getImageMemoryRequirements( Image image,
11364 MemoryRequirements * pMemoryRequirements,
11365 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11366 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11367 // wrapper function for command vkGetImageMemoryRequirements, see
11368 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements.html
11369 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11370 VULKAN_HPP_NODISCARD MemoryRequirements getImageMemoryRequirements( Image image,
11371 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11372 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11373
11374 // wrapper function for command vkGetImageSparseMemoryRequirements, see
11375 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements.html
11376 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11377 void getImageSparseMemoryRequirements( Image image,
11378 uint32_t * pSparseMemoryRequirementCount,
11379 SparseImageMemoryRequirements * pSparseMemoryRequirements,
11380 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11381 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11382 // wrapper function for command vkGetImageSparseMemoryRequirements, see
11383 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements.html
11384 template <
11385 typename SparseImageMemoryRequirementsAllocator = std::allocator<SparseImageMemoryRequirements>,
11386 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11387 typename std::enable_if<std::is_same<typename SparseImageMemoryRequirementsAllocator::value_type, SparseImageMemoryRequirements>::value, int>::type = 0,
11388 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11389 VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator>
11390 getImageSparseMemoryRequirements( Image image, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11391 // wrapper function for command vkGetImageSparseMemoryRequirements, see
11392 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements.html
11393 template <
11394 typename SparseImageMemoryRequirementsAllocator = std::allocator<SparseImageMemoryRequirements>,
11395 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11396 typename std::enable_if<std::is_same<typename SparseImageMemoryRequirementsAllocator::value_type, SparseImageMemoryRequirements>::value, int>::type = 0,
11397 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11398 VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator>
11399 getImageSparseMemoryRequirements( Image image,
11400 SparseImageMemoryRequirementsAllocator & sparseImageMemoryRequirementsAllocator,
11401 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11402 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11403
11404 // wrapper function for command vkCreateFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateFence.html
11405 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11406 VULKAN_HPP_NODISCARD Result createFence( const FenceCreateInfo * pCreateInfo,
11407 const AllocationCallbacks * pAllocator,
11408 Fence * pFence,
11409 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11410 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11411 // wrapper function for command vkCreateFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateFence.html
11412 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11413 VULKAN_HPP_NODISCARD typename ResultValueType<Fence>::type
11414 createFence( const FenceCreateInfo & createInfo,
11415 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
11416 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11417 # ifndef VULKAN_HPP_NO_SMART_HANDLE
11418 // wrapper function for command vkCreateFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateFence.html
11419 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11420 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<Fence, Dispatch>>::type
11421 createFenceUnique( const FenceCreateInfo & createInfo,
11422 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
11423 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11424 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
11425 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11426
11427 // wrapper function for command vkDestroyFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyFence.html
11428 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11429 void destroyFence( Fence fence,
11430 const AllocationCallbacks * pAllocator,
11431 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11432 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11433 // wrapper function for command vkDestroyFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyFence.html
11434 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11435 void destroyFence( Fence fence VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
11436 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
11437 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11438 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11439
11440 // wrapper function for command vkDestroyFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyFence.html
11441 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11442 void destroy( Fence fence, const AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11443 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11444 // wrapper function for command vkDestroyFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyFence.html
11445 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11446 void destroy( Fence fence,
11447 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
11448 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11449 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11450
11451 // wrapper function for command vkResetFences, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetFences.html
11452 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11453 VULKAN_HPP_NODISCARD Result resetFences( uint32_t fenceCount,
11454 const Fence * pFences,
11455 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11456 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11457 // wrapper function for command vkResetFences, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetFences.html
11458 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11459 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
11460 resetFences( ArrayProxy<const Fence> const & fences, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11461 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11462
11463 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
11464 // wrapper function for command vkGetFenceStatus, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFenceStatus.html
11465 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11466 VULKAN_HPP_NODISCARD Result getFenceStatus( Fence fence, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11467 #else
11468 // wrapper function for command vkGetFenceStatus, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFenceStatus.html
11469 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11470 VULKAN_HPP_NODISCARD Result getFenceStatus( Fence fence, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11471 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11472
11473 // wrapper function for command vkWaitForFences, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitForFences.html
11474 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11475 VULKAN_HPP_NODISCARD Result waitForFences( uint32_t fenceCount,
11476 const Fence * pFences,
11477 Bool32 waitAll,
11478 uint64_t timeout,
11479 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11480 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11481 // wrapper function for command vkWaitForFences, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitForFences.html
11482 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11483 VULKAN_HPP_NODISCARD Result waitForFences( ArrayProxy<const Fence> const & fences,
11484 Bool32 waitAll,
11485 uint64_t timeout,
11486 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11487 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11488
11489 // wrapper function for command vkCreateSemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSemaphore.html
11490 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11491 VULKAN_HPP_NODISCARD Result createSemaphore( const SemaphoreCreateInfo * pCreateInfo,
11492 const AllocationCallbacks * pAllocator,
11493 Semaphore * pSemaphore,
11494 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11495 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11496 // wrapper function for command vkCreateSemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSemaphore.html
11497 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11498 VULKAN_HPP_NODISCARD typename ResultValueType<Semaphore>::type
11499 createSemaphore( const SemaphoreCreateInfo & createInfo,
11500 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
11501 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11502 # ifndef VULKAN_HPP_NO_SMART_HANDLE
11503 // wrapper function for command vkCreateSemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSemaphore.html
11504 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11505 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<Semaphore, Dispatch>>::type
11506 createSemaphoreUnique( const SemaphoreCreateInfo & createInfo,
11507 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
11508 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11509 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
11510 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11511
11512 // wrapper function for command vkDestroySemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySemaphore.html
11513 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11514 void destroySemaphore( Semaphore semaphore,
11515 const AllocationCallbacks * pAllocator,
11516 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11517 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11518 // wrapper function for command vkDestroySemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySemaphore.html
11519 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11520 void destroySemaphore( Semaphore semaphore VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
11521 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
11522 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11523 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11524
11525 // wrapper function for command vkDestroySemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySemaphore.html
11526 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11527 void destroy( Semaphore semaphore,
11528 const AllocationCallbacks * pAllocator,
11529 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11530 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11531 // wrapper function for command vkDestroySemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySemaphore.html
11532 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11533 void destroy( Semaphore semaphore,
11534 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
11535 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11536 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11537
11538 // wrapper function for command vkCreateQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateQueryPool.html
11539 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11540 VULKAN_HPP_NODISCARD Result createQueryPool( const QueryPoolCreateInfo * pCreateInfo,
11541 const AllocationCallbacks * pAllocator,
11542 QueryPool * pQueryPool,
11543 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11544 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11545 // wrapper function for command vkCreateQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateQueryPool.html
11546 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11547 VULKAN_HPP_NODISCARD typename ResultValueType<QueryPool>::type
11548 createQueryPool( const QueryPoolCreateInfo & createInfo,
11549 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
11550 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11551 # ifndef VULKAN_HPP_NO_SMART_HANDLE
11552 // wrapper function for command vkCreateQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateQueryPool.html
11553 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11554 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<QueryPool, Dispatch>>::type
11555 createQueryPoolUnique( const QueryPoolCreateInfo & createInfo,
11556 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
11557 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11558 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
11559 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11560
11561 // wrapper function for command vkDestroyQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyQueryPool.html
11562 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11563 void destroyQueryPool( QueryPool queryPool,
11564 const AllocationCallbacks * pAllocator,
11565 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11566 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11567 // wrapper function for command vkDestroyQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyQueryPool.html
11568 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11569 void destroyQueryPool( QueryPool queryPool VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
11570 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
11571 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11572 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11573
11574 // wrapper function for command vkDestroyQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyQueryPool.html
11575 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11576 void destroy( QueryPool queryPool,
11577 const AllocationCallbacks * pAllocator,
11578 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11579 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11580 // wrapper function for command vkDestroyQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyQueryPool.html
11581 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11582 void destroy( QueryPool queryPool,
11583 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
11584 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11585 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11586
11587 // wrapper function for command vkGetQueryPoolResults, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueryPoolResults.html
11588 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11589 VULKAN_HPP_NODISCARD Result getQueryPoolResults( QueryPool queryPool,
11590 uint32_t firstQuery,
11591 uint32_t queryCount,
11592 size_t dataSize,
11593 void * pData,
11594 DeviceSize stride,
11595 QueryResultFlags flags,
11596 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11597 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11598 // wrapper function for command vkGetQueryPoolResults, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueryPoolResults.html
11599 template <typename DataType,
11600 typename DataTypeAllocator = std::allocator<DataType>,
11601 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11602 typename std::enable_if<std::is_same<typename DataTypeAllocator::value_type, DataType>::value, int>::type = 0,
11603 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11604 VULKAN_HPP_NODISCARD ResultValue<std::vector<DataType, DataTypeAllocator>>
11605 getQueryPoolResults( QueryPool queryPool,
11606 uint32_t firstQuery,
11607 uint32_t queryCount,
11608 size_t dataSize,
11609 DeviceSize stride,
11610 QueryResultFlags flags VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
11611 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11612 // wrapper function for command vkGetQueryPoolResults, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueryPoolResults.html
11613 template <typename DataType,
11614 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11615 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11616 VULKAN_HPP_NODISCARD ResultValue<DataType> getQueryPoolResult( QueryPool queryPool,
11617 uint32_t firstQuery,
11618 uint32_t queryCount,
11619 DeviceSize stride,
11620 QueryResultFlags flags VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
11621 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11622 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11623
11624 // wrapper function for command vkCreateBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBuffer.html
11625 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11626 VULKAN_HPP_NODISCARD Result createBuffer( const BufferCreateInfo * pCreateInfo,
11627 const AllocationCallbacks * pAllocator,
11628 Buffer * pBuffer,
11629 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11630 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11631 // wrapper function for command vkCreateBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBuffer.html
11632 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11633 VULKAN_HPP_NODISCARD typename ResultValueType<Buffer>::type
11634 createBuffer( const BufferCreateInfo & createInfo,
11635 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
11636 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11637 # ifndef VULKAN_HPP_NO_SMART_HANDLE
11638 // wrapper function for command vkCreateBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBuffer.html
11639 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11640 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<Buffer, Dispatch>>::type
11641 createBufferUnique( const BufferCreateInfo & createInfo,
11642 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
11643 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11644 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
11645 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11646
11647 // wrapper function for command vkDestroyBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBuffer.html
11648 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11649 void destroyBuffer( Buffer buffer,
11650 const AllocationCallbacks * pAllocator,
11651 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11652 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11653 // wrapper function for command vkDestroyBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBuffer.html
11654 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11655 void destroyBuffer( Buffer buffer VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
11656 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
11657 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11658 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11659
11660 // wrapper function for command vkDestroyBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBuffer.html
11661 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11662 void
11663 destroy( Buffer buffer, const AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11664 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11665 // wrapper function for command vkDestroyBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBuffer.html
11666 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11667 void destroy( Buffer buffer,
11668 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
11669 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11670 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11671
11672 // wrapper function for command vkCreateImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImage.html
11673 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11674 VULKAN_HPP_NODISCARD Result createImage( const ImageCreateInfo * pCreateInfo,
11675 const AllocationCallbacks * pAllocator,
11676 Image * pImage,
11677 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11678 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11679 // wrapper function for command vkCreateImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImage.html
11680 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11681 VULKAN_HPP_NODISCARD typename ResultValueType<Image>::type
11682 createImage( const ImageCreateInfo & createInfo,
11683 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
11684 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11685 # ifndef VULKAN_HPP_NO_SMART_HANDLE
11686 // wrapper function for command vkCreateImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImage.html
11687 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11688 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<Image, Dispatch>>::type
11689 createImageUnique( const ImageCreateInfo & createInfo,
11690 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
11691 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11692 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
11693 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11694
11695 // wrapper function for command vkDestroyImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyImage.html
11696 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11697 void destroyImage( Image image,
11698 const AllocationCallbacks * pAllocator,
11699 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11700 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11701 // wrapper function for command vkDestroyImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyImage.html
11702 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11703 void destroyImage( Image image VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
11704 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
11705 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11706 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11707
11708 // wrapper function for command vkDestroyImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyImage.html
11709 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11710 void destroy( Image image, const AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11711 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11712 // wrapper function for command vkDestroyImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyImage.html
11713 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11714 void destroy( Image image,
11715 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
11716 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11717 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11718
11719 // wrapper function for command vkGetImageSubresourceLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout.html
11720 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11721 void getImageSubresourceLayout( Image image,
11722 const ImageSubresource * pSubresource,
11723 SubresourceLayout * pLayout,
11724 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11725 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11726 // wrapper function for command vkGetImageSubresourceLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout.html
11727 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11728 VULKAN_HPP_NODISCARD SubresourceLayout getImageSubresourceLayout( Image image,
11729 const ImageSubresource & subresource,
11730 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11731 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11732
11733 // wrapper function for command vkCreateImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImageView.html
11734 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11735 VULKAN_HPP_NODISCARD Result createImageView( const ImageViewCreateInfo * pCreateInfo,
11736 const AllocationCallbacks * pAllocator,
11737 ImageView * pView,
11738 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11739 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11740 // wrapper function for command vkCreateImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImageView.html
11741 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11742 VULKAN_HPP_NODISCARD typename ResultValueType<ImageView>::type
11743 createImageView( const ImageViewCreateInfo & createInfo,
11744 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
11745 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11746 # ifndef VULKAN_HPP_NO_SMART_HANDLE
11747 // wrapper function for command vkCreateImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImageView.html
11748 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11749 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<ImageView, Dispatch>>::type
11750 createImageViewUnique( const ImageViewCreateInfo & createInfo,
11751 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
11752 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11753 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
11754 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11755
11756 // wrapper function for command vkDestroyImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyImageView.html
11757 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11758 void destroyImageView( ImageView imageView,
11759 const AllocationCallbacks * pAllocator,
11760 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11761 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11762 // wrapper function for command vkDestroyImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyImageView.html
11763 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11764 void destroyImageView( ImageView imageView VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
11765 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
11766 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11767 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11768
11769 // wrapper function for command vkDestroyImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyImageView.html
11770 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11771 void destroy( ImageView imageView,
11772 const AllocationCallbacks * pAllocator,
11773 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11774 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11775 // wrapper function for command vkDestroyImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyImageView.html
11776 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11777 void destroy( ImageView imageView,
11778 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
11779 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11780 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11781
11782 // wrapper function for command vkCreateCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCommandPool.html
11783 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11784 VULKAN_HPP_NODISCARD Result createCommandPool( const CommandPoolCreateInfo * pCreateInfo,
11785 const AllocationCallbacks * pAllocator,
11786 CommandPool * pCommandPool,
11787 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11788 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11789 // wrapper function for command vkCreateCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCommandPool.html
11790 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11791 VULKAN_HPP_NODISCARD typename ResultValueType<CommandPool>::type
11792 createCommandPool( const CommandPoolCreateInfo & createInfo,
11793 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
11794 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11795 # ifndef VULKAN_HPP_NO_SMART_HANDLE
11796 // wrapper function for command vkCreateCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCommandPool.html
11797 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11798 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<CommandPool, Dispatch>>::type
11799 createCommandPoolUnique( const CommandPoolCreateInfo & createInfo,
11800 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
11801 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11802 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
11803 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11804
11805 // wrapper function for command vkDestroyCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCommandPool.html
11806 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11807 void destroyCommandPool( CommandPool commandPool,
11808 const AllocationCallbacks * pAllocator,
11809 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11810 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11811 // wrapper function for command vkDestroyCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCommandPool.html
11812 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11813 void destroyCommandPool( CommandPool commandPool VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
11814 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
11815 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11816 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11817
11818 // wrapper function for command vkDestroyCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCommandPool.html
11819 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11820 void destroy( CommandPool commandPool,
11821 const AllocationCallbacks * pAllocator,
11822 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11823 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11824 // wrapper function for command vkDestroyCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCommandPool.html
11825 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11826 void destroy( CommandPool commandPool,
11827 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
11828 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11829 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11830
11831 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
11832 // wrapper function for command vkResetCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetCommandPool.html
11833 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11834 VULKAN_HPP_NODISCARD Result resetCommandPool( CommandPool commandPool,
11835 CommandPoolResetFlags flags,
11836 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11837 #else
11838 // wrapper function for command vkResetCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetCommandPool.html
11839 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11840 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
11841 resetCommandPool( CommandPool commandPool,
11842 CommandPoolResetFlags flags VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
11843 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11844 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11845
11846 // wrapper function for command vkAllocateCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateCommandBuffers.html
11847 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11848 VULKAN_HPP_NODISCARD Result allocateCommandBuffers( const CommandBufferAllocateInfo * pAllocateInfo,
11849 CommandBuffer * pCommandBuffers,
11850 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11851 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11852 // wrapper function for command vkAllocateCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateCommandBuffers.html
11853 template <typename CommandBufferAllocator = std::allocator<CommandBuffer>,
11854 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11855 typename std::enable_if<std::is_same<typename CommandBufferAllocator::value_type, CommandBuffer>::value, int>::type = 0,
11856 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11857 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<CommandBuffer, CommandBufferAllocator>>::type
11858 allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11859 // wrapper function for command vkAllocateCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateCommandBuffers.html
11860 template <typename CommandBufferAllocator = std::allocator<CommandBuffer>,
11861 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11862 typename std::enable_if<std::is_same<typename CommandBufferAllocator::value_type, CommandBuffer>::value, int>::type = 0,
11863 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11864 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<CommandBuffer, CommandBufferAllocator>>::type
11865 allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo,
11866 CommandBufferAllocator & commandBufferAllocator,
11867 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11868 # ifndef VULKAN_HPP_NO_SMART_HANDLE
11869 // wrapper function for command vkAllocateCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateCommandBuffers.html
11870 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11871 typename CommandBufferAllocator = std::allocator<UniqueHandle<CommandBuffer, Dispatch>>,
11872 typename std::enable_if<std::is_same<typename CommandBufferAllocator::value_type, UniqueHandle<CommandBuffer, Dispatch>>::value, int>::type = 0,
11873 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11874 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<CommandBuffer, Dispatch>, CommandBufferAllocator>>::type
11875 allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11876 // wrapper function for command vkAllocateCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateCommandBuffers.html
11877 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11878 typename CommandBufferAllocator = std::allocator<UniqueHandle<CommandBuffer, Dispatch>>,
11879 typename std::enable_if<std::is_same<typename CommandBufferAllocator::value_type, UniqueHandle<CommandBuffer, Dispatch>>::value, int>::type = 0,
11880 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11881 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<CommandBuffer, Dispatch>, CommandBufferAllocator>>::type
11882 allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo,
11883 CommandBufferAllocator & commandBufferAllocator,
11884 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11885 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
11886 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11887
11888 // wrapper function for command vkFreeCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeCommandBuffers.html
11889 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11890 void freeCommandBuffers( CommandPool commandPool,
11891 uint32_t commandBufferCount,
11892 const CommandBuffer * pCommandBuffers,
11893 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11894 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11895 // wrapper function for command vkFreeCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeCommandBuffers.html
11896 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11897 void freeCommandBuffers( CommandPool commandPool,
11898 ArrayProxy<const CommandBuffer> const & commandBuffers,
11899 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11900 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11901
11902 // wrapper function for command vkFreeCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeCommandBuffers.html
11903 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11904 void( free )( CommandPool commandPool,
11905 uint32_t commandBufferCount,
11906 const CommandBuffer * pCommandBuffers,
11907 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11908 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11909 // wrapper function for command vkFreeCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeCommandBuffers.html
11910 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11911 void( free )( CommandPool commandPool,
11912 ArrayProxy<const CommandBuffer> const & commandBuffers,
11913 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11914 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11915
11916 // wrapper function for command vkCreateEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateEvent.html
11917 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11918 VULKAN_HPP_NODISCARD Result createEvent( const EventCreateInfo * pCreateInfo,
11919 const AllocationCallbacks * pAllocator,
11920 Event * pEvent,
11921 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11922 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11923 // wrapper function for command vkCreateEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateEvent.html
11924 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11925 VULKAN_HPP_NODISCARD typename ResultValueType<Event>::type
11926 createEvent( const EventCreateInfo & createInfo,
11927 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
11928 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11929 # ifndef VULKAN_HPP_NO_SMART_HANDLE
11930 // wrapper function for command vkCreateEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateEvent.html
11931 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11932 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<Event, Dispatch>>::type
11933 createEventUnique( const EventCreateInfo & createInfo,
11934 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
11935 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11936 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
11937 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11938
11939 // wrapper function for command vkDestroyEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyEvent.html
11940 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11941 void destroyEvent( Event event,
11942 const AllocationCallbacks * pAllocator,
11943 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11944 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11945 // wrapper function for command vkDestroyEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyEvent.html
11946 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11947 void destroyEvent( Event event VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
11948 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
11949 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11950 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11951
11952 // wrapper function for command vkDestroyEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyEvent.html
11953 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11954 void destroy( Event event, const AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11955 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11956 // wrapper function for command vkDestroyEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyEvent.html
11957 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11958 void destroy( Event event,
11959 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
11960 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11961 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11962
11963 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
11964 // wrapper function for command vkGetEventStatus, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEventStatus.html
11965 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11966 VULKAN_HPP_NODISCARD Result getEventStatus( Event event, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11967 #else
11968 // wrapper function for command vkGetEventStatus, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEventStatus.html
11969 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11970 VULKAN_HPP_NODISCARD Result getEventStatus( Event event, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11971 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11972
11973 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
11974 // wrapper function for command vkSetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetEvent.html
11975 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11976 VULKAN_HPP_NODISCARD Result setEvent( Event event, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11977 #else
11978 // wrapper function for command vkSetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetEvent.html
11979 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11980 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type setEvent( Event event,
11981 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11982 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11983
11984 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
11985 // wrapper function for command vkResetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetEvent.html
11986 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11987 VULKAN_HPP_NODISCARD Result resetEvent( Event event, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11988 #else
11989 // wrapper function for command vkResetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetEvent.html
11990 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11991 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
11992 resetEvent( Event event, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11993 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11994
11995 // wrapper function for command vkCreateBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBufferView.html
11996 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
11997 VULKAN_HPP_NODISCARD Result createBufferView( const BufferViewCreateInfo * pCreateInfo,
11998 const AllocationCallbacks * pAllocator,
11999 BufferView * pView,
12000 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12001 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12002 // wrapper function for command vkCreateBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBufferView.html
12003 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12004 VULKAN_HPP_NODISCARD typename ResultValueType<BufferView>::type
12005 createBufferView( const BufferViewCreateInfo & createInfo,
12006 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
12007 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12008 # ifndef VULKAN_HPP_NO_SMART_HANDLE
12009 // wrapper function for command vkCreateBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBufferView.html
12010 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12011 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<BufferView, Dispatch>>::type
12012 createBufferViewUnique( const BufferViewCreateInfo & createInfo,
12013 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
12014 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12015 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
12016 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12017
12018 // wrapper function for command vkDestroyBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBufferView.html
12019 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12020 void destroyBufferView( BufferView bufferView,
12021 const AllocationCallbacks * pAllocator,
12022 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12023 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12024 // wrapper function for command vkDestroyBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBufferView.html
12025 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12026 void destroyBufferView( BufferView bufferView VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
12027 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
12028 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12029 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12030
12031 // wrapper function for command vkDestroyBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBufferView.html
12032 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12033 void destroy( BufferView bufferView,
12034 const AllocationCallbacks * pAllocator,
12035 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12036 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12037 // wrapper function for command vkDestroyBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBufferView.html
12038 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12039 void destroy( BufferView bufferView,
12040 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
12041 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12042 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12043
12044 // wrapper function for command vkCreateShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShaderModule.html
12045 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12046 VULKAN_HPP_NODISCARD Result createShaderModule( const ShaderModuleCreateInfo * pCreateInfo,
12047 const AllocationCallbacks * pAllocator,
12048 ShaderModule * pShaderModule,
12049 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12050 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12051 // wrapper function for command vkCreateShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShaderModule.html
12052 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12053 VULKAN_HPP_NODISCARD typename ResultValueType<ShaderModule>::type
12054 createShaderModule( const ShaderModuleCreateInfo & createInfo,
12055 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
12056 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12057 # ifndef VULKAN_HPP_NO_SMART_HANDLE
12058 // wrapper function for command vkCreateShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShaderModule.html
12059 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12060 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<ShaderModule, Dispatch>>::type
12061 createShaderModuleUnique( const ShaderModuleCreateInfo & createInfo,
12062 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
12063 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12064 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
12065 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12066
12067 // wrapper function for command vkDestroyShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyShaderModule.html
12068 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12069 void destroyShaderModule( ShaderModule shaderModule,
12070 const AllocationCallbacks * pAllocator,
12071 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12072 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12073 // wrapper function for command vkDestroyShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyShaderModule.html
12074 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12075 void destroyShaderModule( ShaderModule shaderModule VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
12076 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
12077 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12078 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12079
12080 // wrapper function for command vkDestroyShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyShaderModule.html
12081 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12082 void destroy( ShaderModule shaderModule,
12083 const AllocationCallbacks * pAllocator,
12084 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12085 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12086 // wrapper function for command vkDestroyShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyShaderModule.html
12087 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12088 void destroy( ShaderModule shaderModule,
12089 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
12090 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12091 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12092
12093 // wrapper function for command vkCreatePipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineCache.html
12094 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12095 VULKAN_HPP_NODISCARD Result createPipelineCache( const PipelineCacheCreateInfo * pCreateInfo,
12096 const AllocationCallbacks * pAllocator,
12097 PipelineCache * pPipelineCache,
12098 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12099 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12100 // wrapper function for command vkCreatePipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineCache.html
12101 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12102 VULKAN_HPP_NODISCARD typename ResultValueType<PipelineCache>::type
12103 createPipelineCache( const PipelineCacheCreateInfo & createInfo,
12104 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
12105 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12106 # ifndef VULKAN_HPP_NO_SMART_HANDLE
12107 // wrapper function for command vkCreatePipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineCache.html
12108 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12109 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<PipelineCache, Dispatch>>::type
12110 createPipelineCacheUnique( const PipelineCacheCreateInfo & createInfo,
12111 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
12112 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12113 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
12114 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12115
12116 // wrapper function for command vkDestroyPipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineCache.html
12117 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12118 void destroyPipelineCache( PipelineCache pipelineCache,
12119 const AllocationCallbacks * pAllocator,
12120 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12121 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12122 // wrapper function for command vkDestroyPipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineCache.html
12123 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12124 void destroyPipelineCache( PipelineCache pipelineCache VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
12125 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
12126 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12127 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12128
12129 // wrapper function for command vkDestroyPipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineCache.html
12130 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12131 void destroy( PipelineCache pipelineCache,
12132 const AllocationCallbacks * pAllocator,
12133 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12134 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12135 // wrapper function for command vkDestroyPipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineCache.html
12136 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12137 void destroy( PipelineCache pipelineCache,
12138 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
12139 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12140 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12141
12142 // wrapper function for command vkGetPipelineCacheData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineCacheData.html
12143 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12144 VULKAN_HPP_NODISCARD Result getPipelineCacheData( PipelineCache pipelineCache,
12145 size_t * pDataSize,
12146 void * pData,
12147 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12148 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12149 // wrapper function for command vkGetPipelineCacheData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineCacheData.html
12150 template <typename Uint8_tAllocator = std::allocator<uint8_t>,
12151 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12152 typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0,
12153 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12154 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
12155 getPipelineCacheData( PipelineCache pipelineCache, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12156 // wrapper function for command vkGetPipelineCacheData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineCacheData.html
12157 template <typename Uint8_tAllocator = std::allocator<uint8_t>,
12158 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12159 typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0,
12160 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12161 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type getPipelineCacheData(
12162 PipelineCache pipelineCache, Uint8_tAllocator & uint8_tAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12163 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12164
12165 // wrapper function for command vkMergePipelineCaches, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMergePipelineCaches.html
12166 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12167 VULKAN_HPP_NODISCARD Result mergePipelineCaches( PipelineCache dstCache,
12168 uint32_t srcCacheCount,
12169 const PipelineCache * pSrcCaches,
12170 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12171 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12172 // wrapper function for command vkMergePipelineCaches, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMergePipelineCaches.html
12173 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12174 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type mergePipelineCaches(
12175 PipelineCache dstCache, ArrayProxy<const PipelineCache> const & srcCaches, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12176 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12177
12178 // wrapper function for command vkCreateComputePipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateComputePipelines.html
12179 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12180 VULKAN_HPP_NODISCARD Result createComputePipelines( PipelineCache pipelineCache,
12181 uint32_t createInfoCount,
12182 const ComputePipelineCreateInfo * pCreateInfos,
12183 const AllocationCallbacks * pAllocator,
12184 Pipeline * pPipelines,
12185 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12186 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12187 // wrapper function for command vkCreateComputePipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateComputePipelines.html
12188 template <typename PipelineAllocator = std::allocator<Pipeline>,
12189 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12190 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, Pipeline>::value, int>::type = 0,
12191 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12192 VULKAN_HPP_NODISCARD ResultValue<std::vector<Pipeline, PipelineAllocator>>
12193 createComputePipelines( PipelineCache pipelineCache,
12194 ArrayProxy<const ComputePipelineCreateInfo> const & createInfos,
12195 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
12196 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12197 // wrapper function for command vkCreateComputePipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateComputePipelines.html
12198 template <typename PipelineAllocator = std::allocator<Pipeline>,
12199 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12200 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, Pipeline>::value, int>::type = 0,
12201 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12202 VULKAN_HPP_NODISCARD ResultValue<std::vector<Pipeline, PipelineAllocator>>
12203 createComputePipelines( PipelineCache pipelineCache,
12204 ArrayProxy<const ComputePipelineCreateInfo> const & createInfos,
12205 Optional<const AllocationCallbacks> allocator,
12206 PipelineAllocator & pipelineAllocator,
12207 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12208 // wrapper function for command vkCreateComputePipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateComputePipelines.html
12209 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12210 VULKAN_HPP_NODISCARD ResultValue<Pipeline> createComputePipeline( PipelineCache pipelineCache,
12211 const ComputePipelineCreateInfo & createInfo,
12212 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
12213 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12214 # ifndef VULKAN_HPP_NO_SMART_HANDLE
12215 // wrapper function for command vkCreateComputePipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateComputePipelines.html
12216 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12217 typename PipelineAllocator = std::allocator<UniqueHandle<Pipeline, Dispatch>>,
12218 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<Pipeline, Dispatch>>::value, int>::type = 0,
12219 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12220 VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
12221 createComputePipelinesUnique( PipelineCache pipelineCache,
12222 ArrayProxy<const ComputePipelineCreateInfo> const & createInfos,
12223 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
12224 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12225 // wrapper function for command vkCreateComputePipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateComputePipelines.html
12226 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12227 typename PipelineAllocator = std::allocator<UniqueHandle<Pipeline, Dispatch>>,
12228 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<Pipeline, Dispatch>>::value, int>::type = 0,
12229 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12230 VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
12231 createComputePipelinesUnique( PipelineCache pipelineCache,
12232 ArrayProxy<const ComputePipelineCreateInfo> const & createInfos,
12233 Optional<const AllocationCallbacks> allocator,
12234 PipelineAllocator & pipelineAllocator,
12235 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12236 // wrapper function for command vkCreateComputePipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateComputePipelines.html
12237 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12238 VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<Pipeline, Dispatch>>
12239 createComputePipelineUnique( PipelineCache pipelineCache,
12240 const ComputePipelineCreateInfo & createInfo,
12241 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
12242 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12243 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
12244 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12245
12246 // wrapper function for command vkDestroyPipeline, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipeline.html
12247 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12248 void destroyPipeline( Pipeline pipeline,
12249 const AllocationCallbacks * pAllocator,
12250 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12251 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12252 // wrapper function for command vkDestroyPipeline, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipeline.html
12253 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12254 void destroyPipeline( Pipeline pipeline VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
12255 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
12256 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12257 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12258
12259 // wrapper function for command vkDestroyPipeline, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipeline.html
12260 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12261 void destroy( Pipeline pipeline,
12262 const AllocationCallbacks * pAllocator,
12263 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12264 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12265 // wrapper function for command vkDestroyPipeline, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipeline.html
12266 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12267 void destroy( Pipeline pipeline,
12268 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
12269 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12270 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12271
12272 // wrapper function for command vkCreatePipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineLayout.html
12273 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12274 VULKAN_HPP_NODISCARD Result createPipelineLayout( const PipelineLayoutCreateInfo * pCreateInfo,
12275 const AllocationCallbacks * pAllocator,
12276 PipelineLayout * pPipelineLayout,
12277 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12278 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12279 // wrapper function for command vkCreatePipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineLayout.html
12280 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12281 VULKAN_HPP_NODISCARD typename ResultValueType<PipelineLayout>::type
12282 createPipelineLayout( const PipelineLayoutCreateInfo & createInfo,
12283 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
12284 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12285 # ifndef VULKAN_HPP_NO_SMART_HANDLE
12286 // wrapper function for command vkCreatePipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineLayout.html
12287 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12288 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<PipelineLayout, Dispatch>>::type
12289 createPipelineLayoutUnique( const PipelineLayoutCreateInfo & createInfo,
12290 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
12291 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12292 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
12293 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12294
12295 // wrapper function for command vkDestroyPipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineLayout.html
12296 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12297 void destroyPipelineLayout( PipelineLayout pipelineLayout,
12298 const AllocationCallbacks * pAllocator,
12299 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12300 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12301 // wrapper function for command vkDestroyPipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineLayout.html
12302 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12303 void destroyPipelineLayout( PipelineLayout pipelineLayout VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
12304 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
12305 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12306 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12307
12308 // wrapper function for command vkDestroyPipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineLayout.html
12309 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12310 void destroy( PipelineLayout pipelineLayout,
12311 const AllocationCallbacks * pAllocator,
12312 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12313 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12314 // wrapper function for command vkDestroyPipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineLayout.html
12315 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12316 void destroy( PipelineLayout pipelineLayout,
12317 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
12318 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12319 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12320
12321 // wrapper function for command vkCreateSampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSampler.html
12322 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12323 VULKAN_HPP_NODISCARD Result createSampler( const SamplerCreateInfo * pCreateInfo,
12324 const AllocationCallbacks * pAllocator,
12325 Sampler * pSampler,
12326 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12327 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12328 // wrapper function for command vkCreateSampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSampler.html
12329 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12330 VULKAN_HPP_NODISCARD typename ResultValueType<Sampler>::type
12331 createSampler( const SamplerCreateInfo & createInfo,
12332 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
12333 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12334 # ifndef VULKAN_HPP_NO_SMART_HANDLE
12335 // wrapper function for command vkCreateSampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSampler.html
12336 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12337 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<Sampler, Dispatch>>::type
12338 createSamplerUnique( const SamplerCreateInfo & createInfo,
12339 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
12340 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12341 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
12342 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12343
12344 // wrapper function for command vkDestroySampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySampler.html
12345 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12346 void destroySampler( Sampler sampler,
12347 const AllocationCallbacks * pAllocator,
12348 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12349 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12350 // wrapper function for command vkDestroySampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySampler.html
12351 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12352 void destroySampler( Sampler sampler VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
12353 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
12354 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12355 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12356
12357 // wrapper function for command vkDestroySampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySampler.html
12358 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12359 void
12360 destroy( Sampler sampler, const AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12361 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12362 // wrapper function for command vkDestroySampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySampler.html
12363 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12364 void destroy( Sampler sampler,
12365 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
12366 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12367 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12368
12369 // wrapper function for command vkCreateDescriptorSetLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorSetLayout.html
12370 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12371 VULKAN_HPP_NODISCARD Result createDescriptorSetLayout( const DescriptorSetLayoutCreateInfo * pCreateInfo,
12372 const AllocationCallbacks * pAllocator,
12373 DescriptorSetLayout * pSetLayout,
12374 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12375 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12376 // wrapper function for command vkCreateDescriptorSetLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorSetLayout.html
12377 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12378 VULKAN_HPP_NODISCARD typename ResultValueType<DescriptorSetLayout>::type
12379 createDescriptorSetLayout( const DescriptorSetLayoutCreateInfo & createInfo,
12380 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
12381 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12382 # ifndef VULKAN_HPP_NO_SMART_HANDLE
12383 // wrapper function for command vkCreateDescriptorSetLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorSetLayout.html
12384 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12385 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<DescriptorSetLayout, Dispatch>>::type
12386 createDescriptorSetLayoutUnique( const DescriptorSetLayoutCreateInfo & createInfo,
12387 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
12388 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12389 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
12390 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12391
12392 // wrapper function for command vkDestroyDescriptorSetLayout, see
12393 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorSetLayout.html
12394 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12395 void destroyDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout,
12396 const AllocationCallbacks * pAllocator,
12397 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12398 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12399 // wrapper function for command vkDestroyDescriptorSetLayout, see
12400 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorSetLayout.html
12401 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12402 void destroyDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
12403 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
12404 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12405 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12406
12407 // wrapper function for command vkDestroyDescriptorSetLayout, see
12408 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorSetLayout.html
12409 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12410 void destroy( DescriptorSetLayout descriptorSetLayout,
12411 const AllocationCallbacks * pAllocator,
12412 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12413 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12414 // wrapper function for command vkDestroyDescriptorSetLayout, see
12415 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorSetLayout.html
12416 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12417 void destroy( DescriptorSetLayout descriptorSetLayout,
12418 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
12419 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12420 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12421
12422 // wrapper function for command vkCreateDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorPool.html
12423 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12424 VULKAN_HPP_NODISCARD Result createDescriptorPool( const DescriptorPoolCreateInfo * pCreateInfo,
12425 const AllocationCallbacks * pAllocator,
12426 DescriptorPool * pDescriptorPool,
12427 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12428 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12429 // wrapper function for command vkCreateDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorPool.html
12430 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12431 VULKAN_HPP_NODISCARD typename ResultValueType<DescriptorPool>::type
12432 createDescriptorPool( const DescriptorPoolCreateInfo & createInfo,
12433 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
12434 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12435 # ifndef VULKAN_HPP_NO_SMART_HANDLE
12436 // wrapper function for command vkCreateDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorPool.html
12437 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12438 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<DescriptorPool, Dispatch>>::type
12439 createDescriptorPoolUnique( const DescriptorPoolCreateInfo & createInfo,
12440 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
12441 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12442 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
12443 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12444
12445 // wrapper function for command vkDestroyDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorPool.html
12446 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12447 void destroyDescriptorPool( DescriptorPool descriptorPool,
12448 const AllocationCallbacks * pAllocator,
12449 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12450 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12451 // wrapper function for command vkDestroyDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorPool.html
12452 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12453 void destroyDescriptorPool( DescriptorPool descriptorPool VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
12454 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
12455 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12456 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12457
12458 // wrapper function for command vkDestroyDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorPool.html
12459 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12460 void destroy( DescriptorPool descriptorPool,
12461 const AllocationCallbacks * pAllocator,
12462 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12463 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12464 // wrapper function for command vkDestroyDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorPool.html
12465 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12466 void destroy( DescriptorPool descriptorPool,
12467 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
12468 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12469 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12470
12471 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
12472 // wrapper function for command vkResetDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetDescriptorPool.html
12473 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12474 VULKAN_HPP_NODISCARD Result resetDescriptorPool( DescriptorPool descriptorPool,
12475 DescriptorPoolResetFlags flags,
12476 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12477 #else
12478 // wrapper function for command vkResetDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetDescriptorPool.html
12479 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12480 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
12481 resetDescriptorPool( DescriptorPool descriptorPool,
12482 DescriptorPoolResetFlags flags VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
12483 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12484 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12485
12486 // wrapper function for command vkAllocateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateDescriptorSets.html
12487 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12488 VULKAN_HPP_NODISCARD Result allocateDescriptorSets( const DescriptorSetAllocateInfo * pAllocateInfo,
12489 DescriptorSet * pDescriptorSets,
12490 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12491 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12492 // wrapper function for command vkAllocateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateDescriptorSets.html
12493 template <typename DescriptorSetAllocator = std::allocator<DescriptorSet>,
12494 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12495 typename std::enable_if<std::is_same<typename DescriptorSetAllocator::value_type, DescriptorSet>::value, int>::type = 0,
12496 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12497 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DescriptorSet, DescriptorSetAllocator>>::type
12498 allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12499 // wrapper function for command vkAllocateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateDescriptorSets.html
12500 template <typename DescriptorSetAllocator = std::allocator<DescriptorSet>,
12501 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12502 typename std::enable_if<std::is_same<typename DescriptorSetAllocator::value_type, DescriptorSet>::value, int>::type = 0,
12503 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12504 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DescriptorSet, DescriptorSetAllocator>>::type
12505 allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo,
12506 DescriptorSetAllocator & descriptorSetAllocator,
12507 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12508 # ifndef VULKAN_HPP_NO_SMART_HANDLE
12509 // wrapper function for command vkAllocateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateDescriptorSets.html
12510 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12511 typename DescriptorSetAllocator = std::allocator<UniqueHandle<DescriptorSet, Dispatch>>,
12512 typename std::enable_if<std::is_same<typename DescriptorSetAllocator::value_type, UniqueHandle<DescriptorSet, Dispatch>>::value, int>::type = 0,
12513 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12514 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<DescriptorSet, Dispatch>, DescriptorSetAllocator>>::type
12515 allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12516 // wrapper function for command vkAllocateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateDescriptorSets.html
12517 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12518 typename DescriptorSetAllocator = std::allocator<UniqueHandle<DescriptorSet, Dispatch>>,
12519 typename std::enable_if<std::is_same<typename DescriptorSetAllocator::value_type, UniqueHandle<DescriptorSet, Dispatch>>::value, int>::type = 0,
12520 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12521 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<DescriptorSet, Dispatch>, DescriptorSetAllocator>>::type
12522 allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo,
12523 DescriptorSetAllocator & descriptorSetAllocator,
12524 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12525 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
12526 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12527
12528 // wrapper function for command vkFreeDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeDescriptorSets.html
12529 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12530 VULKAN_HPP_NODISCARD Result freeDescriptorSets( DescriptorPool descriptorPool,
12531 uint32_t descriptorSetCount,
12532 const DescriptorSet * pDescriptorSets,
12533 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12534 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12535 // wrapper function for command vkFreeDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeDescriptorSets.html
12536 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12537 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
12538 freeDescriptorSets( DescriptorPool descriptorPool,
12539 ArrayProxy<const DescriptorSet> const & descriptorSets,
12540 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12541 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12542
12543 // wrapper function for command vkFreeDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeDescriptorSets.html
12544 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12545 VULKAN_HPP_NODISCARD Result( free )( DescriptorPool descriptorPool,
12546 uint32_t descriptorSetCount,
12547 const DescriptorSet * pDescriptorSets,
12548 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12549 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12550 // wrapper function for command vkFreeDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeDescriptorSets.html
12551 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12552 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type( free )( DescriptorPool descriptorPool,
12553 ArrayProxy<const DescriptorSet> const & descriptorSets,
12554 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12555 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12556
12557 // wrapper function for command vkUpdateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateDescriptorSets.html
12558 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12559 void updateDescriptorSets( uint32_t descriptorWriteCount,
12560 const WriteDescriptorSet * pDescriptorWrites,
12561 uint32_t descriptorCopyCount,
12562 const CopyDescriptorSet * pDescriptorCopies,
12563 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12564 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12565 // wrapper function for command vkUpdateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateDescriptorSets.html
12566 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12567 void updateDescriptorSets( ArrayProxy<const WriteDescriptorSet> const & descriptorWrites,
12568 ArrayProxy<const CopyDescriptorSet> const & descriptorCopies,
12569 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12570 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12571
12572 // wrapper function for command vkCreateGraphicsPipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGraphicsPipelines.html
12573 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12574 VULKAN_HPP_NODISCARD Result createGraphicsPipelines( PipelineCache pipelineCache,
12575 uint32_t createInfoCount,
12576 const GraphicsPipelineCreateInfo * pCreateInfos,
12577 const AllocationCallbacks * pAllocator,
12578 Pipeline * pPipelines,
12579 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12580 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12581 // wrapper function for command vkCreateGraphicsPipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGraphicsPipelines.html
12582 template <typename PipelineAllocator = std::allocator<Pipeline>,
12583 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12584 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, Pipeline>::value, int>::type = 0,
12585 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12586 VULKAN_HPP_NODISCARD ResultValue<std::vector<Pipeline, PipelineAllocator>>
12587 createGraphicsPipelines( PipelineCache pipelineCache,
12588 ArrayProxy<const GraphicsPipelineCreateInfo> const & createInfos,
12589 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
12590 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12591 // wrapper function for command vkCreateGraphicsPipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGraphicsPipelines.html
12592 template <typename PipelineAllocator = std::allocator<Pipeline>,
12593 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12594 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, Pipeline>::value, int>::type = 0,
12595 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12596 VULKAN_HPP_NODISCARD ResultValue<std::vector<Pipeline, PipelineAllocator>>
12597 createGraphicsPipelines( PipelineCache pipelineCache,
12598 ArrayProxy<const GraphicsPipelineCreateInfo> const & createInfos,
12599 Optional<const AllocationCallbacks> allocator,
12600 PipelineAllocator & pipelineAllocator,
12601 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12602 // wrapper function for command vkCreateGraphicsPipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGraphicsPipelines.html
12603 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12604 VULKAN_HPP_NODISCARD ResultValue<Pipeline> createGraphicsPipeline( PipelineCache pipelineCache,
12605 const GraphicsPipelineCreateInfo & createInfo,
12606 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
12607 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12608 # ifndef VULKAN_HPP_NO_SMART_HANDLE
12609 // wrapper function for command vkCreateGraphicsPipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGraphicsPipelines.html
12610 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12611 typename PipelineAllocator = std::allocator<UniqueHandle<Pipeline, Dispatch>>,
12612 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<Pipeline, Dispatch>>::value, int>::type = 0,
12613 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12614 VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
12615 createGraphicsPipelinesUnique( PipelineCache pipelineCache,
12616 ArrayProxy<const GraphicsPipelineCreateInfo> const & createInfos,
12617 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
12618 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12619 // wrapper function for command vkCreateGraphicsPipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGraphicsPipelines.html
12620 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12621 typename PipelineAllocator = std::allocator<UniqueHandle<Pipeline, Dispatch>>,
12622 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<Pipeline, Dispatch>>::value, int>::type = 0,
12623 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12624 VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
12625 createGraphicsPipelinesUnique( PipelineCache pipelineCache,
12626 ArrayProxy<const GraphicsPipelineCreateInfo> const & createInfos,
12627 Optional<const AllocationCallbacks> allocator,
12628 PipelineAllocator & pipelineAllocator,
12629 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12630 // wrapper function for command vkCreateGraphicsPipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGraphicsPipelines.html
12631 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12632 VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<Pipeline, Dispatch>>
12633 createGraphicsPipelineUnique( PipelineCache pipelineCache,
12634 const GraphicsPipelineCreateInfo & createInfo,
12635 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
12636 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12637 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
12638 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12639
12640 // wrapper function for command vkCreateFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateFramebuffer.html
12641 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12642 VULKAN_HPP_NODISCARD Result createFramebuffer( const FramebufferCreateInfo * pCreateInfo,
12643 const AllocationCallbacks * pAllocator,
12644 Framebuffer * pFramebuffer,
12645 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12646 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12647 // wrapper function for command vkCreateFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateFramebuffer.html
12648 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12649 VULKAN_HPP_NODISCARD typename ResultValueType<Framebuffer>::type
12650 createFramebuffer( const FramebufferCreateInfo & createInfo,
12651 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
12652 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12653 # ifndef VULKAN_HPP_NO_SMART_HANDLE
12654 // wrapper function for command vkCreateFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateFramebuffer.html
12655 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12656 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<Framebuffer, Dispatch>>::type
12657 createFramebufferUnique( const FramebufferCreateInfo & createInfo,
12658 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
12659 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12660 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
12661 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12662
12663 // wrapper function for command vkDestroyFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyFramebuffer.html
12664 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12665 void destroyFramebuffer( Framebuffer framebuffer,
12666 const AllocationCallbacks * pAllocator,
12667 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12668 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12669 // wrapper function for command vkDestroyFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyFramebuffer.html
12670 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12671 void destroyFramebuffer( Framebuffer framebuffer VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
12672 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
12673 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12674 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12675
12676 // wrapper function for command vkDestroyFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyFramebuffer.html
12677 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12678 void destroy( Framebuffer framebuffer,
12679 const AllocationCallbacks * pAllocator,
12680 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12681 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12682 // wrapper function for command vkDestroyFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyFramebuffer.html
12683 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12684 void destroy( Framebuffer framebuffer,
12685 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
12686 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12687 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12688
12689 // wrapper function for command vkCreateRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass.html
12690 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12691 VULKAN_HPP_NODISCARD Result createRenderPass( const RenderPassCreateInfo * pCreateInfo,
12692 const AllocationCallbacks * pAllocator,
12693 RenderPass * pRenderPass,
12694 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12695 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12696 // wrapper function for command vkCreateRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass.html
12697 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12698 VULKAN_HPP_NODISCARD typename ResultValueType<RenderPass>::type
12699 createRenderPass( const RenderPassCreateInfo & createInfo,
12700 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
12701 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12702 # ifndef VULKAN_HPP_NO_SMART_HANDLE
12703 // wrapper function for command vkCreateRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass.html
12704 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12705 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<RenderPass, Dispatch>>::type
12706 createRenderPassUnique( const RenderPassCreateInfo & createInfo,
12707 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
12708 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12709 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
12710 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12711
12712 // wrapper function for command vkDestroyRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyRenderPass.html
12713 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12714 void destroyRenderPass( RenderPass renderPass,
12715 const AllocationCallbacks * pAllocator,
12716 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12717 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12718 // wrapper function for command vkDestroyRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyRenderPass.html
12719 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12720 void destroyRenderPass( RenderPass renderPass VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
12721 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
12722 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12723 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12724
12725 // wrapper function for command vkDestroyRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyRenderPass.html
12726 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12727 void destroy( RenderPass renderPass,
12728 const AllocationCallbacks * pAllocator,
12729 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12730 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12731 // wrapper function for command vkDestroyRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyRenderPass.html
12732 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12733 void destroy( RenderPass renderPass,
12734 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
12735 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12736 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12737
12738 // wrapper function for command vkGetRenderAreaGranularity, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRenderAreaGranularity.html
12739 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12740 void getRenderAreaGranularity( RenderPass renderPass,
12741 Extent2D * pGranularity,
12742 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12743 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12744 // wrapper function for command vkGetRenderAreaGranularity, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRenderAreaGranularity.html
12745 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12746 VULKAN_HPP_NODISCARD Extent2D getRenderAreaGranularity( RenderPass renderPass,
12747 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12748 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12749
12750 //=== VK_VERSION_1_1 ===
12751
12752 // wrapper function for command vkBindBufferMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindBufferMemory2.html
12753 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12754 VULKAN_HPP_NODISCARD Result bindBufferMemory2( uint32_t bindInfoCount,
12755 const BindBufferMemoryInfo * pBindInfos,
12756 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12757 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12758 // wrapper function for command vkBindBufferMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindBufferMemory2.html
12759 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12760 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
12761 bindBufferMemory2( ArrayProxy<const BindBufferMemoryInfo> const & bindInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12762 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12763
12764 // wrapper function for command vkBindImageMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindImageMemory2.html
12765 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12766 VULKAN_HPP_NODISCARD Result bindImageMemory2( uint32_t bindInfoCount,
12767 const BindImageMemoryInfo * pBindInfos,
12768 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12769 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12770 // wrapper function for command vkBindImageMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindImageMemory2.html
12771 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12772 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
12773 bindImageMemory2( ArrayProxy<const BindImageMemoryInfo> const & bindInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12774 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12775
12776 // wrapper function for command vkGetDeviceGroupPeerMemoryFeatures, see
12777 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupPeerMemoryFeatures.html
12778 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12779 void getGroupPeerMemoryFeatures( uint32_t heapIndex,
12780 uint32_t localDeviceIndex,
12781 uint32_t remoteDeviceIndex,
12782 PeerMemoryFeatureFlags * pPeerMemoryFeatures,
12783 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12784 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12785 // wrapper function for command vkGetDeviceGroupPeerMemoryFeatures, see
12786 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupPeerMemoryFeatures.html
12787 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12788 VULKAN_HPP_NODISCARD PeerMemoryFeatureFlags
12789 getGroupPeerMemoryFeatures( uint32_t heapIndex,
12790 uint32_t localDeviceIndex,
12791 uint32_t remoteDeviceIndex,
12792 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12793 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12794
12795 // wrapper function for command vkGetImageMemoryRequirements2, see
12796 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements2.html
12797 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12798 void getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 * pInfo,
12799 MemoryRequirements2 * pMemoryRequirements,
12800 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12801 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12802 // wrapper function for command vkGetImageMemoryRequirements2, see
12803 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements2.html
12804 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12805 VULKAN_HPP_NODISCARD MemoryRequirements2 getImageMemoryRequirements2(
12806 const ImageMemoryRequirementsInfo2 & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12807 // wrapper function for command vkGetImageMemoryRequirements2, see
12808 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements2.html
12809 template <typename X,
12810 typename Y,
12811 typename... Z,
12812 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12813 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12814 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
12815 getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info,
12816 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12817 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12818
12819 // wrapper function for command vkGetBufferMemoryRequirements2, see
12820 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements2.html
12821 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12822 void getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 * pInfo,
12823 MemoryRequirements2 * pMemoryRequirements,
12824 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12825 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12826 // wrapper function for command vkGetBufferMemoryRequirements2, see
12827 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements2.html
12828 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12829 VULKAN_HPP_NODISCARD MemoryRequirements2 getBufferMemoryRequirements2(
12830 const BufferMemoryRequirementsInfo2 & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12831 // wrapper function for command vkGetBufferMemoryRequirements2, see
12832 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements2.html
12833 template <typename X,
12834 typename Y,
12835 typename... Z,
12836 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12837 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12838 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
12839 getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info,
12840 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12841 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12842
12843 // wrapper function for command vkGetImageSparseMemoryRequirements2, see
12844 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements2.html
12845 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12846 void getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 * pInfo,
12847 uint32_t * pSparseMemoryRequirementCount,
12848 SparseImageMemoryRequirements2 * pSparseMemoryRequirements,
12849 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12850 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12851 // wrapper function for command vkGetImageSparseMemoryRequirements2, see
12852 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements2.html
12853 template <
12854 typename SparseImageMemoryRequirements2Allocator = std::allocator<SparseImageMemoryRequirements2>,
12855 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12856 typename std::enable_if<std::is_same<typename SparseImageMemoryRequirements2Allocator::value_type, SparseImageMemoryRequirements2>::value, int>::type = 0,
12857 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12858 VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
12859 getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12860 // wrapper function for command vkGetImageSparseMemoryRequirements2, see
12861 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements2.html
12862 template <
12863 typename SparseImageMemoryRequirements2Allocator = std::allocator<SparseImageMemoryRequirements2>,
12864 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12865 typename std::enable_if<std::is_same<typename SparseImageMemoryRequirements2Allocator::value_type, SparseImageMemoryRequirements2>::value, int>::type = 0,
12866 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12867 VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
12868 getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 & info,
12869 SparseImageMemoryRequirements2Allocator & sparseImageMemoryRequirements2Allocator,
12870 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12871 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12872
12873 // wrapper function for command vkTrimCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkTrimCommandPool.html
12874 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12875 void trimCommandPool( CommandPool commandPool,
12876 CommandPoolTrimFlags flags,
12877 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12878
12879 // wrapper function for command vkGetDeviceQueue2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceQueue2.html
12880 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12881 void
12882 getQueue2( const DeviceQueueInfo2 * pQueueInfo, Queue * pQueue, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12883 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12884 // wrapper function for command vkGetDeviceQueue2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceQueue2.html
12885 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12886 VULKAN_HPP_NODISCARD Queue getQueue2( const DeviceQueueInfo2 & queueInfo,
12887 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12888 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12889
12890 // wrapper function for command vkCreateDescriptorUpdateTemplate, see
12891 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorUpdateTemplate.html
12892 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12893 VULKAN_HPP_NODISCARD Result createDescriptorUpdateTemplate( const DescriptorUpdateTemplateCreateInfo * pCreateInfo,
12894 const AllocationCallbacks * pAllocator,
12895 DescriptorUpdateTemplate * pDescriptorUpdateTemplate,
12896 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12897 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12898 // wrapper function for command vkCreateDescriptorUpdateTemplate, see
12899 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorUpdateTemplate.html
12900 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12901 VULKAN_HPP_NODISCARD typename ResultValueType<DescriptorUpdateTemplate>::type
12902 createDescriptorUpdateTemplate( const DescriptorUpdateTemplateCreateInfo & createInfo,
12903 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
12904 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12905 # ifndef VULKAN_HPP_NO_SMART_HANDLE
12906 // wrapper function for command vkCreateDescriptorUpdateTemplate, see
12907 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorUpdateTemplate.html
12908 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12909 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<DescriptorUpdateTemplate, Dispatch>>::type
12910 createDescriptorUpdateTemplateUnique( const DescriptorUpdateTemplateCreateInfo & createInfo,
12911 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
12912 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12913 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
12914 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12915
12916 // wrapper function for command vkDestroyDescriptorUpdateTemplate, see
12917 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorUpdateTemplate.html
12918 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12919 void destroyDescriptorUpdateTemplate( DescriptorUpdateTemplate descriptorUpdateTemplate,
12920 const AllocationCallbacks * pAllocator,
12921 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12922 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12923 // wrapper function for command vkDestroyDescriptorUpdateTemplate, see
12924 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorUpdateTemplate.html
12925 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12926 void destroyDescriptorUpdateTemplate( DescriptorUpdateTemplate descriptorUpdateTemplate VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
12927 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
12928 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12929 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12930
12931 // wrapper function for command vkDestroyDescriptorUpdateTemplate, see
12932 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorUpdateTemplate.html
12933 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12934 void destroy( DescriptorUpdateTemplate descriptorUpdateTemplate,
12935 const AllocationCallbacks * pAllocator,
12936 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12937 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12938 // wrapper function for command vkDestroyDescriptorUpdateTemplate, see
12939 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorUpdateTemplate.html
12940 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12941 void destroy( DescriptorUpdateTemplate descriptorUpdateTemplate,
12942 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
12943 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12944 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12945
12946 // wrapper function for command vkUpdateDescriptorSetWithTemplate, see
12947 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateDescriptorSetWithTemplate.html
12948 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12949 void updateDescriptorSetWithTemplate( DescriptorSet descriptorSet,
12950 DescriptorUpdateTemplate descriptorUpdateTemplate,
12951 const void * pData,
12952 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12953 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12954 // wrapper function for command vkUpdateDescriptorSetWithTemplate, see
12955 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateDescriptorSetWithTemplate.html
12956 template <typename DataType,
12957 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12958 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12959 void updateDescriptorSetWithTemplate( DescriptorSet descriptorSet,
12960 DescriptorUpdateTemplate descriptorUpdateTemplate,
12961 DataType const & data,
12962 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12963 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12964
12965 // wrapper function for command vkGetDescriptorSetLayoutSupport, see
12966 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSupport.html
12967 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12968 void getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo * pCreateInfo,
12969 DescriptorSetLayoutSupport * pSupport,
12970 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12971 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12972 // wrapper function for command vkGetDescriptorSetLayoutSupport, see
12973 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSupport.html
12974 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12975 VULKAN_HPP_NODISCARD DescriptorSetLayoutSupport getDescriptorSetLayoutSupport(
12976 const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12977 // wrapper function for command vkGetDescriptorSetLayoutSupport, see
12978 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSupport.html
12979 template <typename X,
12980 typename Y,
12981 typename... Z,
12982 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12983 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12984 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
12985 getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo,
12986 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12987 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12988
12989 // wrapper function for command vkCreateSamplerYcbcrConversion, see
12990 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSamplerYcbcrConversion.html
12991 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
12992 VULKAN_HPP_NODISCARD Result createSamplerYcbcrConversion( const SamplerYcbcrConversionCreateInfo * pCreateInfo,
12993 const AllocationCallbacks * pAllocator,
12994 SamplerYcbcrConversion * pYcbcrConversion,
12995 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12996 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12997 // wrapper function for command vkCreateSamplerYcbcrConversion, see
12998 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSamplerYcbcrConversion.html
12999 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13000 VULKAN_HPP_NODISCARD typename ResultValueType<SamplerYcbcrConversion>::type
13001 createSamplerYcbcrConversion( const SamplerYcbcrConversionCreateInfo & createInfo,
13002 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
13003 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13004 # ifndef VULKAN_HPP_NO_SMART_HANDLE
13005 // wrapper function for command vkCreateSamplerYcbcrConversion, see
13006 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSamplerYcbcrConversion.html
13007 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13008 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<SamplerYcbcrConversion, Dispatch>>::type
13009 createSamplerYcbcrConversionUnique( const SamplerYcbcrConversionCreateInfo & createInfo,
13010 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
13011 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13012 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
13013 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13014
13015 // wrapper function for command vkDestroySamplerYcbcrConversion, see
13016 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySamplerYcbcrConversion.html
13017 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13018 void destroySamplerYcbcrConversion( SamplerYcbcrConversion ycbcrConversion,
13019 const AllocationCallbacks * pAllocator,
13020 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13021 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13022 // wrapper function for command vkDestroySamplerYcbcrConversion, see
13023 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySamplerYcbcrConversion.html
13024 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13025 void destroySamplerYcbcrConversion( SamplerYcbcrConversion ycbcrConversion VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
13026 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
13027 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13028 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13029
13030 // wrapper function for command vkDestroySamplerYcbcrConversion, see
13031 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySamplerYcbcrConversion.html
13032 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13033 void destroy( SamplerYcbcrConversion ycbcrConversion,
13034 const AllocationCallbacks * pAllocator,
13035 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13036 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13037 // wrapper function for command vkDestroySamplerYcbcrConversion, see
13038 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySamplerYcbcrConversion.html
13039 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13040 void destroy( SamplerYcbcrConversion ycbcrConversion,
13041 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
13042 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13043 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13044
13045 //=== VK_VERSION_1_2 ===
13046
13047 // wrapper function for command vkResetQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetQueryPool.html
13048 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13049 void resetQueryPool( QueryPool queryPool,
13050 uint32_t firstQuery,
13051 uint32_t queryCount,
13052 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13053
13054 // wrapper function for command vkGetSemaphoreCounterValue, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreCounterValue.html
13055 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13056 VULKAN_HPP_NODISCARD Result getSemaphoreCounterValue( Semaphore semaphore,
13057 uint64_t * pValue,
13058 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13059 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13060 // wrapper function for command vkGetSemaphoreCounterValue, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreCounterValue.html
13061 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13062 VULKAN_HPP_NODISCARD typename ResultValueType<uint64_t>::type getSemaphoreCounterValue( Semaphore semaphore,
13063 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13064 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13065
13066 // wrapper function for command vkWaitSemaphores, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitSemaphores.html
13067 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13068 VULKAN_HPP_NODISCARD Result waitSemaphores( const SemaphoreWaitInfo * pWaitInfo,
13069 uint64_t timeout,
13070 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13071 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13072 // wrapper function for command vkWaitSemaphores, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitSemaphores.html
13073 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13074 VULKAN_HPP_NODISCARD Result waitSemaphores( const SemaphoreWaitInfo & waitInfo,
13075 uint64_t timeout,
13076 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13077 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13078
13079 // wrapper function for command vkSignalSemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSignalSemaphore.html
13080 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13081 VULKAN_HPP_NODISCARD Result signalSemaphore( const SemaphoreSignalInfo * pSignalInfo,
13082 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13083 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13084 // wrapper function for command vkSignalSemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSignalSemaphore.html
13085 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13086 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
13087 signalSemaphore( const SemaphoreSignalInfo & signalInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13088 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13089
13090 // wrapper function for command vkGetBufferDeviceAddress, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferDeviceAddress.html
13091 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13092 DeviceAddress getBufferAddress( const BufferDeviceAddressInfo * pInfo,
13093 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13094 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13095 // wrapper function for command vkGetBufferDeviceAddress, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferDeviceAddress.html
13096 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13097 DeviceAddress getBufferAddress( const BufferDeviceAddressInfo & info,
13098 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13099 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13100
13101 // wrapper function for command vkGetBufferOpaqueCaptureAddress, see
13102 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferOpaqueCaptureAddress.html
13103 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13104 uint64_t getBufferOpaqueCaptureAddress( const BufferDeviceAddressInfo * pInfo,
13105 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13106 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13107 // wrapper function for command vkGetBufferOpaqueCaptureAddress, see
13108 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferOpaqueCaptureAddress.html
13109 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13110 uint64_t getBufferOpaqueCaptureAddress( const BufferDeviceAddressInfo & info,
13111 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13112 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13113
13114 // wrapper function for command vkGetDeviceMemoryOpaqueCaptureAddress, see
13115 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMemoryOpaqueCaptureAddress.html
13116 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13117 uint64_t getMemoryOpaqueCaptureAddress( const DeviceMemoryOpaqueCaptureAddressInfo * pInfo,
13118 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13119 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13120 // wrapper function for command vkGetDeviceMemoryOpaqueCaptureAddress, see
13121 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMemoryOpaqueCaptureAddress.html
13122 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13123 uint64_t getMemoryOpaqueCaptureAddress( const DeviceMemoryOpaqueCaptureAddressInfo & info,
13124 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13125 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13126
13127 // wrapper function for command vkCreateRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass2.html
13128 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13129 VULKAN_HPP_NODISCARD Result createRenderPass2( const RenderPassCreateInfo2 * pCreateInfo,
13130 const AllocationCallbacks * pAllocator,
13131 RenderPass * pRenderPass,
13132 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13133 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13134 // wrapper function for command vkCreateRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass2.html
13135 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13136 VULKAN_HPP_NODISCARD typename ResultValueType<RenderPass>::type
13137 createRenderPass2( const RenderPassCreateInfo2 & createInfo,
13138 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
13139 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13140 # ifndef VULKAN_HPP_NO_SMART_HANDLE
13141 // wrapper function for command vkCreateRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass2.html
13142 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13143 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<RenderPass, Dispatch>>::type
13144 createRenderPass2Unique( const RenderPassCreateInfo2 & createInfo,
13145 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
13146 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13147 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
13148 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13149
13150 //=== VK_VERSION_1_3 ===
13151
13152 // wrapper function for command vkCreatePrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePrivateDataSlot.html
13153 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13154 VULKAN_HPP_NODISCARD Result createPrivateDataSlot( const PrivateDataSlotCreateInfo * pCreateInfo,
13155 const AllocationCallbacks * pAllocator,
13156 PrivateDataSlot * pPrivateDataSlot,
13157 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13158 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13159 // wrapper function for command vkCreatePrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePrivateDataSlot.html
13160 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13161 VULKAN_HPP_NODISCARD typename ResultValueType<PrivateDataSlot>::type
13162 createPrivateDataSlot( const PrivateDataSlotCreateInfo & createInfo,
13163 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
13164 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13165 # ifndef VULKAN_HPP_NO_SMART_HANDLE
13166 // wrapper function for command vkCreatePrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePrivateDataSlot.html
13167 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13168 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<PrivateDataSlot, Dispatch>>::type
13169 createPrivateDataSlotUnique( const PrivateDataSlotCreateInfo & createInfo,
13170 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
13171 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13172 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
13173 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13174
13175 // wrapper function for command vkDestroyPrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPrivateDataSlot.html
13176 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13177 void destroyPrivateDataSlot( PrivateDataSlot privateDataSlot,
13178 const AllocationCallbacks * pAllocator,
13179 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13180 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13181 // wrapper function for command vkDestroyPrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPrivateDataSlot.html
13182 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13183 void destroyPrivateDataSlot( PrivateDataSlot privateDataSlot VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
13184 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
13185 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13186 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13187
13188 // wrapper function for command vkDestroyPrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPrivateDataSlot.html
13189 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13190 void destroy( PrivateDataSlot privateDataSlot,
13191 const AllocationCallbacks * pAllocator,
13192 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13193 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13194 // wrapper function for command vkDestroyPrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPrivateDataSlot.html
13195 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13196 void destroy( PrivateDataSlot privateDataSlot,
13197 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
13198 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13199 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13200
13201 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
13202 // wrapper function for command vkSetPrivateData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetPrivateData.html
13203 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13204 VULKAN_HPP_NODISCARD Result setPrivateData( ObjectType objectType,
13205 uint64_t objectHandle,
13206 PrivateDataSlot privateDataSlot,
13207 uint64_t data,
13208 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13209 #else
13210 // wrapper function for command vkSetPrivateData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetPrivateData.html
13211 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13212 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
13213 setPrivateData( ObjectType objectType,
13214 uint64_t objectHandle,
13215 PrivateDataSlot privateDataSlot,
13216 uint64_t data,
13217 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13218 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13219
13220 // wrapper function for command vkGetPrivateData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPrivateData.html
13221 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13222 void getPrivateData( ObjectType objectType,
13223 uint64_t objectHandle,
13224 PrivateDataSlot privateDataSlot,
13225 uint64_t * pData,
13226 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13227 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13228 // wrapper function for command vkGetPrivateData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPrivateData.html
13229 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13230 VULKAN_HPP_NODISCARD uint64_t getPrivateData( ObjectType objectType,
13231 uint64_t objectHandle,
13232 PrivateDataSlot privateDataSlot,
13233 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13234 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13235
13236 // wrapper function for command vkGetDeviceBufferMemoryRequirements, see
13237 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceBufferMemoryRequirements.html
13238 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13239 void getBufferMemoryRequirements( const DeviceBufferMemoryRequirements * pInfo,
13240 MemoryRequirements2 * pMemoryRequirements,
13241 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13242 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13243 // wrapper function for command vkGetDeviceBufferMemoryRequirements, see
13244 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceBufferMemoryRequirements.html
13245 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13246 VULKAN_HPP_NODISCARD MemoryRequirements2 getBufferMemoryRequirements(
13247 const DeviceBufferMemoryRequirements & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13248 // wrapper function for command vkGetDeviceBufferMemoryRequirements, see
13249 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceBufferMemoryRequirements.html
13250 template <typename X,
13251 typename Y,
13252 typename... Z,
13253 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13254 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13255 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
13256 getBufferMemoryRequirements( const DeviceBufferMemoryRequirements & info,
13257 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13258 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13259
13260 // wrapper function for command vkGetDeviceImageMemoryRequirements, see
13261 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageMemoryRequirements.html
13262 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13263 void getImageMemoryRequirements( const DeviceImageMemoryRequirements * pInfo,
13264 MemoryRequirements2 * pMemoryRequirements,
13265 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13266 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13267 // wrapper function for command vkGetDeviceImageMemoryRequirements, see
13268 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageMemoryRequirements.html
13269 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13270 VULKAN_HPP_NODISCARD MemoryRequirements2 getImageMemoryRequirements(
13271 const DeviceImageMemoryRequirements & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13272 // wrapper function for command vkGetDeviceImageMemoryRequirements, see
13273 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageMemoryRequirements.html
13274 template <typename X,
13275 typename Y,
13276 typename... Z,
13277 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13278 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13279 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
13280 getImageMemoryRequirements( const DeviceImageMemoryRequirements & info,
13281 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13282 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13283
13284 // wrapper function for command vkGetDeviceImageSparseMemoryRequirements, see
13285 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSparseMemoryRequirements.html
13286 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13287 void getImageSparseMemoryRequirements( const DeviceImageMemoryRequirements * pInfo,
13288 uint32_t * pSparseMemoryRequirementCount,
13289 SparseImageMemoryRequirements2 * pSparseMemoryRequirements,
13290 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13291 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13292 // wrapper function for command vkGetDeviceImageSparseMemoryRequirements, see
13293 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSparseMemoryRequirements.html
13294 template <
13295 typename SparseImageMemoryRequirements2Allocator = std::allocator<SparseImageMemoryRequirements2>,
13296 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13297 typename std::enable_if<std::is_same<typename SparseImageMemoryRequirements2Allocator::value_type, SparseImageMemoryRequirements2>::value, int>::type = 0,
13298 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13299 VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
13300 getImageSparseMemoryRequirements( const DeviceImageMemoryRequirements & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13301 // wrapper function for command vkGetDeviceImageSparseMemoryRequirements, see
13302 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSparseMemoryRequirements.html
13303 template <
13304 typename SparseImageMemoryRequirements2Allocator = std::allocator<SparseImageMemoryRequirements2>,
13305 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13306 typename std::enable_if<std::is_same<typename SparseImageMemoryRequirements2Allocator::value_type, SparseImageMemoryRequirements2>::value, int>::type = 0,
13307 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13308 VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
13309 getImageSparseMemoryRequirements( const DeviceImageMemoryRequirements & info,
13310 SparseImageMemoryRequirements2Allocator & sparseImageMemoryRequirements2Allocator,
13311 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13312 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13313
13314 //=== VK_VERSION_1_4 ===
13315
13316 // wrapper function for command vkMapMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMapMemory2.html
13317 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13318 VULKAN_HPP_NODISCARD Result mapMemory2( const MemoryMapInfo * pMemoryMapInfo,
13319 void ** ppData,
13320 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13321 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13322 // wrapper function for command vkMapMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMapMemory2.html
13323 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13324 VULKAN_HPP_NODISCARD typename ResultValueType<void *>::type mapMemory2( const MemoryMapInfo & memoryMapInfo,
13325 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13326 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13327
13328 // wrapper function for command vkUnmapMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnmapMemory2.html
13329 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13330 VULKAN_HPP_NODISCARD Result unmapMemory2( const MemoryUnmapInfo * pMemoryUnmapInfo,
13331 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13332 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13333 // wrapper function for command vkUnmapMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnmapMemory2.html
13334 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13335 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
13336 unmapMemory2( const MemoryUnmapInfo & memoryUnmapInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13337 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13338
13339 // wrapper function for command vkGetDeviceImageSubresourceLayout, see
13340 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSubresourceLayout.html
13341 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13342 void getImageSubresourceLayout( const DeviceImageSubresourceInfo * pInfo,
13343 SubresourceLayout2 * pLayout,
13344 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13345 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13346 // wrapper function for command vkGetDeviceImageSubresourceLayout, see
13347 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSubresourceLayout.html
13348 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13349 VULKAN_HPP_NODISCARD SubresourceLayout2 getImageSubresourceLayout( const DeviceImageSubresourceInfo & info,
13350 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13351 // wrapper function for command vkGetDeviceImageSubresourceLayout, see
13352 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSubresourceLayout.html
13353 template <typename X,
13354 typename Y,
13355 typename... Z,
13356 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13357 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13358 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
13359 getImageSubresourceLayout( const DeviceImageSubresourceInfo & info,
13360 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13361 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13362
13363 // wrapper function for command vkGetImageSubresourceLayout2, see
13364 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2.html
13365 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13366 void getImageSubresourceLayout2( Image image,
13367 const ImageSubresource2 * pSubresource,
13368 SubresourceLayout2 * pLayout,
13369 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13370 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13371 // wrapper function for command vkGetImageSubresourceLayout2, see
13372 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2.html
13373 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13374 VULKAN_HPP_NODISCARD SubresourceLayout2 getImageSubresourceLayout2( Image image,
13375 const ImageSubresource2 & subresource,
13376 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13377 // wrapper function for command vkGetImageSubresourceLayout2, see
13378 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2.html
13379 template <typename X,
13380 typename Y,
13381 typename... Z,
13382 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13383 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13384 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getImageSubresourceLayout2(
13385 Image image, const ImageSubresource2 & subresource, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13386 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13387
13388 // wrapper function for command vkCopyMemoryToImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToImage.html
13389 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13390 VULKAN_HPP_NODISCARD Result copyMemoryToImage( const CopyMemoryToImageInfo * pCopyMemoryToImageInfo,
13391 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13392 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13393 // wrapper function for command vkCopyMemoryToImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToImage.html
13394 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13395 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
13396 copyMemoryToImage( const CopyMemoryToImageInfo & copyMemoryToImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13397 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13398
13399 // wrapper function for command vkCopyImageToMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToMemory.html
13400 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13401 VULKAN_HPP_NODISCARD Result copyImageToMemory( const CopyImageToMemoryInfo * pCopyImageToMemoryInfo,
13402 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13403 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13404 // wrapper function for command vkCopyImageToMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToMemory.html
13405 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13406 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
13407 copyImageToMemory( const CopyImageToMemoryInfo & copyImageToMemoryInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13408 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13409
13410 // wrapper function for command vkCopyImageToImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToImage.html
13411 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13412 VULKAN_HPP_NODISCARD Result copyImageToImage( const CopyImageToImageInfo * pCopyImageToImageInfo,
13413 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13414 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13415 // wrapper function for command vkCopyImageToImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToImage.html
13416 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13417 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
13418 copyImageToImage( const CopyImageToImageInfo & copyImageToImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13419 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13420
13421 // wrapper function for command vkTransitionImageLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkTransitionImageLayout.html
13422 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13423 VULKAN_HPP_NODISCARD Result transitionImageLayout( uint32_t transitionCount,
13424 const HostImageLayoutTransitionInfo * pTransitions,
13425 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13426 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13427 // wrapper function for command vkTransitionImageLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkTransitionImageLayout.html
13428 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13429 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
13430 transitionImageLayout( ArrayProxy<const HostImageLayoutTransitionInfo> const & transitions,
13431 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13432 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13433
13434 // wrapper function for command vkGetRenderingAreaGranularity, see
13435 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRenderingAreaGranularity.html
13436 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13437 void getRenderingAreaGranularity( const RenderingAreaInfo * pRenderingAreaInfo,
13438 Extent2D * pGranularity,
13439 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13440 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13441 // wrapper function for command vkGetRenderingAreaGranularity, see
13442 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRenderingAreaGranularity.html
13443 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13444 VULKAN_HPP_NODISCARD Extent2D getRenderingAreaGranularity( const RenderingAreaInfo & renderingAreaInfo,
13445 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13446 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13447
13448 //=== VK_KHR_swapchain ===
13449
13450 // wrapper function for command vkCreateSwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSwapchainKHR.html
13451 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13452 VULKAN_HPP_NODISCARD Result createSwapchainKHR( const SwapchainCreateInfoKHR * pCreateInfo,
13453 const AllocationCallbacks * pAllocator,
13454 SwapchainKHR * pSwapchain,
13455 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13456 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13457 // wrapper function for command vkCreateSwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSwapchainKHR.html
13458 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13459 VULKAN_HPP_NODISCARD typename ResultValueType<SwapchainKHR>::type
13460 createSwapchainKHR( const SwapchainCreateInfoKHR & createInfo,
13461 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
13462 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13463 # ifndef VULKAN_HPP_NO_SMART_HANDLE
13464 // wrapper function for command vkCreateSwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSwapchainKHR.html
13465 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13466 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<SwapchainKHR, Dispatch>>::type
13467 createSwapchainKHRUnique( const SwapchainCreateInfoKHR & createInfo,
13468 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
13469 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13470 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
13471 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13472
13473 // wrapper function for command vkDestroySwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySwapchainKHR.html
13474 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13475 void destroySwapchainKHR( SwapchainKHR swapchain,
13476 const AllocationCallbacks * pAllocator,
13477 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13478 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13479 // wrapper function for command vkDestroySwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySwapchainKHR.html
13480 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13481 void destroySwapchainKHR( SwapchainKHR swapchain VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
13482 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
13483 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13484 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13485
13486 // wrapper function for command vkDestroySwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySwapchainKHR.html
13487 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13488 void destroy( SwapchainKHR swapchain,
13489 const AllocationCallbacks * pAllocator,
13490 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13491 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13492 // wrapper function for command vkDestroySwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySwapchainKHR.html
13493 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13494 void destroy( SwapchainKHR swapchain,
13495 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
13496 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13497 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13498
13499 // wrapper function for command vkGetSwapchainImagesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainImagesKHR.html
13500 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13501 VULKAN_HPP_NODISCARD Result getSwapchainImagesKHR( SwapchainKHR swapchain,
13502 uint32_t * pSwapchainImageCount,
13503 Image * pSwapchainImages,
13504 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13505 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13506 // wrapper function for command vkGetSwapchainImagesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainImagesKHR.html
13507 template <typename ImageAllocator = std::allocator<Image>,
13508 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13509 typename std::enable_if<std::is_same<typename ImageAllocator::value_type, Image>::value, int>::type = 0,
13510 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13511 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<Image, ImageAllocator>>::type
13512 getSwapchainImagesKHR( SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13513 // wrapper function for command vkGetSwapchainImagesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainImagesKHR.html
13514 template <typename ImageAllocator = std::allocator<Image>,
13515 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13516 typename std::enable_if<std::is_same<typename ImageAllocator::value_type, Image>::value, int>::type = 0,
13517 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13518 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<Image, ImageAllocator>>::type
13519 getSwapchainImagesKHR( SwapchainKHR swapchain, ImageAllocator & imageAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13520 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13521
13522 // wrapper function for command vkAcquireNextImageKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireNextImageKHR.html
13523 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13524 VULKAN_HPP_NODISCARD Result acquireNextImageKHR( SwapchainKHR swapchain,
13525 uint64_t timeout,
13526 Semaphore semaphore,
13527 Fence fence,
13528 uint32_t * pImageIndex,
13529 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13530 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13531 // wrapper function for command vkAcquireNextImageKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireNextImageKHR.html
13532 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13533 VULKAN_HPP_NODISCARD ResultValue<uint32_t> acquireNextImageKHR( SwapchainKHR swapchain,
13534 uint64_t timeout,
13535 Semaphore semaphore VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
13536 Fence fence VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
13537 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13538 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13539
13540 // wrapper function for command vkGetDeviceGroupPresentCapabilitiesKHR, see
13541 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupPresentCapabilitiesKHR.html
13542 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13543 VULKAN_HPP_NODISCARD Result getGroupPresentCapabilitiesKHR( DeviceGroupPresentCapabilitiesKHR * pDeviceGroupPresentCapabilities,
13544 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13545 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13546 // wrapper function for command vkGetDeviceGroupPresentCapabilitiesKHR, see
13547 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupPresentCapabilitiesKHR.html
13548 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13549 VULKAN_HPP_NODISCARD typename ResultValueType<DeviceGroupPresentCapabilitiesKHR>::type
13550 getGroupPresentCapabilitiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13551 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13552
13553 // wrapper function for command vkGetDeviceGroupSurfacePresentModesKHR, see
13554 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupSurfacePresentModesKHR.html
13555 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13556 VULKAN_HPP_NODISCARD Result getGroupSurfacePresentModesKHR( SurfaceKHR surface,
13557 DeviceGroupPresentModeFlagsKHR * pModes,
13558 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13559 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13560 // wrapper function for command vkGetDeviceGroupSurfacePresentModesKHR, see
13561 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupSurfacePresentModesKHR.html
13562 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13563 VULKAN_HPP_NODISCARD typename ResultValueType<DeviceGroupPresentModeFlagsKHR>::type
13564 getGroupSurfacePresentModesKHR( SurfaceKHR surface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13565 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13566
13567 // wrapper function for command vkAcquireNextImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireNextImage2KHR.html
13568 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13569 VULKAN_HPP_NODISCARD Result acquireNextImage2KHR( const AcquireNextImageInfoKHR * pAcquireInfo,
13570 uint32_t * pImageIndex,
13571 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13572 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13573 // wrapper function for command vkAcquireNextImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireNextImage2KHR.html
13574 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13575 VULKAN_HPP_NODISCARD ResultValue<uint32_t> acquireNextImage2KHR( const AcquireNextImageInfoKHR & acquireInfo,
13576 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13577 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13578
13579 //=== VK_KHR_display_swapchain ===
13580
13581 // wrapper function for command vkCreateSharedSwapchainsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSharedSwapchainsKHR.html
13582 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13583 VULKAN_HPP_NODISCARD Result createSharedSwapchainsKHR( uint32_t swapchainCount,
13584 const SwapchainCreateInfoKHR * pCreateInfos,
13585 const AllocationCallbacks * pAllocator,
13586 SwapchainKHR * pSwapchains,
13587 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13588 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13589 // wrapper function for command vkCreateSharedSwapchainsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSharedSwapchainsKHR.html
13590 template <typename SwapchainKHRAllocator = std::allocator<SwapchainKHR>,
13591 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13592 typename std::enable_if<std::is_same<typename SwapchainKHRAllocator::value_type, SwapchainKHR>::value, int>::type = 0,
13593 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13594 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<SwapchainKHR, SwapchainKHRAllocator>>::type
13595 createSharedSwapchainsKHR( ArrayProxy<const SwapchainCreateInfoKHR> const & createInfos,
13596 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
13597 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13598 // wrapper function for command vkCreateSharedSwapchainsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSharedSwapchainsKHR.html
13599 template <typename SwapchainKHRAllocator = std::allocator<SwapchainKHR>,
13600 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13601 typename std::enable_if<std::is_same<typename SwapchainKHRAllocator::value_type, SwapchainKHR>::value, int>::type = 0,
13602 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13603 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<SwapchainKHR, SwapchainKHRAllocator>>::type
13604 createSharedSwapchainsKHR( ArrayProxy<const SwapchainCreateInfoKHR> const & createInfos,
13605 Optional<const AllocationCallbacks> allocator,
13606 SwapchainKHRAllocator & swapchainKHRAllocator,
13607 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13608 // wrapper function for command vkCreateSharedSwapchainsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSharedSwapchainsKHR.html
13609 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13610 VULKAN_HPP_NODISCARD typename ResultValueType<SwapchainKHR>::type
13611 createSharedSwapchainKHR( const SwapchainCreateInfoKHR & createInfo,
13612 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
13613 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13614 # ifndef VULKAN_HPP_NO_SMART_HANDLE
13615 // wrapper function for command vkCreateSharedSwapchainsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSharedSwapchainsKHR.html
13616 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13617 typename SwapchainKHRAllocator = std::allocator<UniqueHandle<SwapchainKHR, Dispatch>>,
13618 typename std::enable_if<std::is_same<typename SwapchainKHRAllocator::value_type, UniqueHandle<SwapchainKHR, Dispatch>>::value, int>::type = 0,
13619 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13620 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<SwapchainKHR, Dispatch>, SwapchainKHRAllocator>>::type
13621 createSharedSwapchainsKHRUnique( ArrayProxy<const SwapchainCreateInfoKHR> const & createInfos,
13622 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
13623 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13624 // wrapper function for command vkCreateSharedSwapchainsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSharedSwapchainsKHR.html
13625 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13626 typename SwapchainKHRAllocator = std::allocator<UniqueHandle<SwapchainKHR, Dispatch>>,
13627 typename std::enable_if<std::is_same<typename SwapchainKHRAllocator::value_type, UniqueHandle<SwapchainKHR, Dispatch>>::value, int>::type = 0,
13628 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13629 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<SwapchainKHR, Dispatch>, SwapchainKHRAllocator>>::type
13630 createSharedSwapchainsKHRUnique( ArrayProxy<const SwapchainCreateInfoKHR> const & createInfos,
13631 Optional<const AllocationCallbacks> allocator,
13632 SwapchainKHRAllocator & swapchainKHRAllocator,
13633 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13634 // wrapper function for command vkCreateSharedSwapchainsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSharedSwapchainsKHR.html
13635 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13636 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<SwapchainKHR, Dispatch>>::type
13637 createSharedSwapchainKHRUnique( const SwapchainCreateInfoKHR & createInfo,
13638 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
13639 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13640 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
13641 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13642
13643 //=== VK_EXT_debug_marker ===
13644
13645 // wrapper function for command vkDebugMarkerSetObjectTagEXT, see
13646 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDebugMarkerSetObjectTagEXT.html
13647 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13648 VULKAN_HPP_NODISCARD Result debugMarkerSetObjectTagEXT( const DebugMarkerObjectTagInfoEXT * pTagInfo,
13649 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13650 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13651 // wrapper function for command vkDebugMarkerSetObjectTagEXT, see
13652 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDebugMarkerSetObjectTagEXT.html
13653 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13654 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
13655 debugMarkerSetObjectTagEXT( const DebugMarkerObjectTagInfoEXT & tagInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13656 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13657
13658 // wrapper function for command vkDebugMarkerSetObjectNameEXT, see
13659 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDebugMarkerSetObjectNameEXT.html
13660 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13661 VULKAN_HPP_NODISCARD Result debugMarkerSetObjectNameEXT( const DebugMarkerObjectNameInfoEXT * pNameInfo,
13662 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13663 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13664 // wrapper function for command vkDebugMarkerSetObjectNameEXT, see
13665 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDebugMarkerSetObjectNameEXT.html
13666 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13667 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
13668 debugMarkerSetObjectNameEXT( const DebugMarkerObjectNameInfoEXT & nameInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13669 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13670
13671 //=== VK_KHR_video_queue ===
13672
13673 // wrapper function for command vkCreateVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateVideoSessionKHR.html
13674 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13675 VULKAN_HPP_NODISCARD Result createVideoSessionKHR( const VideoSessionCreateInfoKHR * pCreateInfo,
13676 const AllocationCallbacks * pAllocator,
13677 VideoSessionKHR * pVideoSession,
13678 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13679 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13680 // wrapper function for command vkCreateVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateVideoSessionKHR.html
13681 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13682 VULKAN_HPP_NODISCARD typename ResultValueType<VideoSessionKHR>::type
13683 createVideoSessionKHR( const VideoSessionCreateInfoKHR & createInfo,
13684 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
13685 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13686 # ifndef VULKAN_HPP_NO_SMART_HANDLE
13687 // wrapper function for command vkCreateVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateVideoSessionKHR.html
13688 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13689 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VideoSessionKHR, Dispatch>>::type
13690 createVideoSessionKHRUnique( const VideoSessionCreateInfoKHR & createInfo,
13691 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
13692 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13693 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
13694 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13695
13696 // wrapper function for command vkDestroyVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyVideoSessionKHR.html
13697 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13698 void destroyVideoSessionKHR( VideoSessionKHR videoSession,
13699 const AllocationCallbacks * pAllocator,
13700 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13701 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13702 // wrapper function for command vkDestroyVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyVideoSessionKHR.html
13703 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13704 void destroyVideoSessionKHR( VideoSessionKHR videoSession VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
13705 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
13706 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13707 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13708
13709 // wrapper function for command vkDestroyVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyVideoSessionKHR.html
13710 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13711 void destroy( VideoSessionKHR videoSession,
13712 const AllocationCallbacks * pAllocator,
13713 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13714 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13715 // wrapper function for command vkDestroyVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyVideoSessionKHR.html
13716 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13717 void destroy( VideoSessionKHR videoSession,
13718 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
13719 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13720 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13721
13722 // wrapper function for command vkGetVideoSessionMemoryRequirementsKHR, see
13723 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetVideoSessionMemoryRequirementsKHR.html
13724 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13725 VULKAN_HPP_NODISCARD Result getVideoSessionMemoryRequirementsKHR( VideoSessionKHR videoSession,
13726 uint32_t * pMemoryRequirementsCount,
13727 VideoSessionMemoryRequirementsKHR * pMemoryRequirements,
13728 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13729 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13730 // wrapper function for command vkGetVideoSessionMemoryRequirementsKHR, see
13731 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetVideoSessionMemoryRequirementsKHR.html
13732 template <typename VideoSessionMemoryRequirementsKHRAllocator = std::allocator<VideoSessionMemoryRequirementsKHR>,
13733 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13734 typename std::enable_if<std::is_same<typename VideoSessionMemoryRequirementsKHRAllocator::value_type, VideoSessionMemoryRequirementsKHR>::value,
13735 int>::type = 0,
13736 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13737 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VideoSessionMemoryRequirementsKHR, VideoSessionMemoryRequirementsKHRAllocator>>::type
13738 getVideoSessionMemoryRequirementsKHR( VideoSessionKHR videoSession, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13739 // wrapper function for command vkGetVideoSessionMemoryRequirementsKHR, see
13740 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetVideoSessionMemoryRequirementsKHR.html
13741 template <typename VideoSessionMemoryRequirementsKHRAllocator = std::allocator<VideoSessionMemoryRequirementsKHR>,
13742 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13743 typename std::enable_if<std::is_same<typename VideoSessionMemoryRequirementsKHRAllocator::value_type, VideoSessionMemoryRequirementsKHR>::value,
13744 int>::type = 0,
13745 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13746 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VideoSessionMemoryRequirementsKHR, VideoSessionMemoryRequirementsKHRAllocator>>::type
13747 getVideoSessionMemoryRequirementsKHR( VideoSessionKHR videoSession,
13748 VideoSessionMemoryRequirementsKHRAllocator & videoSessionMemoryRequirementsKHRAllocator,
13749 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13750 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13751
13752 // wrapper function for command vkBindVideoSessionMemoryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindVideoSessionMemoryKHR.html
13753 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13754 VULKAN_HPP_NODISCARD Result bindVideoSessionMemoryKHR( VideoSessionKHR videoSession,
13755 uint32_t bindSessionMemoryInfoCount,
13756 const BindVideoSessionMemoryInfoKHR * pBindSessionMemoryInfos,
13757 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13758 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13759 // wrapper function for command vkBindVideoSessionMemoryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindVideoSessionMemoryKHR.html
13760 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13761 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
13762 bindVideoSessionMemoryKHR( VideoSessionKHR videoSession,
13763 ArrayProxy<const BindVideoSessionMemoryInfoKHR> const & bindSessionMemoryInfos,
13764 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13765 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13766
13767 // wrapper function for command vkCreateVideoSessionParametersKHR, see
13768 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateVideoSessionParametersKHR.html
13769 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13770 VULKAN_HPP_NODISCARD Result createVideoSessionParametersKHR( const VideoSessionParametersCreateInfoKHR * pCreateInfo,
13771 const AllocationCallbacks * pAllocator,
13772 VideoSessionParametersKHR * pVideoSessionParameters,
13773 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13774 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13775 // wrapper function for command vkCreateVideoSessionParametersKHR, see
13776 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateVideoSessionParametersKHR.html
13777 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13778 VULKAN_HPP_NODISCARD typename ResultValueType<VideoSessionParametersKHR>::type
13779 createVideoSessionParametersKHR( const VideoSessionParametersCreateInfoKHR & createInfo,
13780 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
13781 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13782 # ifndef VULKAN_HPP_NO_SMART_HANDLE
13783 // wrapper function for command vkCreateVideoSessionParametersKHR, see
13784 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateVideoSessionParametersKHR.html
13785 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13786 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VideoSessionParametersKHR, Dispatch>>::type
13787 createVideoSessionParametersKHRUnique( const VideoSessionParametersCreateInfoKHR & createInfo,
13788 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
13789 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13790 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
13791 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13792
13793 // wrapper function for command vkUpdateVideoSessionParametersKHR, see
13794 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateVideoSessionParametersKHR.html
13795 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13796 VULKAN_HPP_NODISCARD Result updateVideoSessionParametersKHR( VideoSessionParametersKHR videoSessionParameters,
13797 const VideoSessionParametersUpdateInfoKHR * pUpdateInfo,
13798 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13799 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13800 // wrapper function for command vkUpdateVideoSessionParametersKHR, see
13801 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateVideoSessionParametersKHR.html
13802 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13803 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
13804 updateVideoSessionParametersKHR( VideoSessionParametersKHR videoSessionParameters,
13805 const VideoSessionParametersUpdateInfoKHR & updateInfo,
13806 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13807 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13808
13809 // wrapper function for command vkDestroyVideoSessionParametersKHR, see
13810 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyVideoSessionParametersKHR.html
13811 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13812 void destroyVideoSessionParametersKHR( VideoSessionParametersKHR videoSessionParameters,
13813 const AllocationCallbacks * pAllocator,
13814 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13815 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13816 // wrapper function for command vkDestroyVideoSessionParametersKHR, see
13817 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyVideoSessionParametersKHR.html
13818 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13819 void destroyVideoSessionParametersKHR( VideoSessionParametersKHR videoSessionParameters VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
13820 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
13821 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13822 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13823
13824 // wrapper function for command vkDestroyVideoSessionParametersKHR, see
13825 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyVideoSessionParametersKHR.html
13826 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13827 void destroy( VideoSessionParametersKHR videoSessionParameters,
13828 const AllocationCallbacks * pAllocator,
13829 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13830 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13831 // wrapper function for command vkDestroyVideoSessionParametersKHR, see
13832 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyVideoSessionParametersKHR.html
13833 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13834 void destroy( VideoSessionParametersKHR videoSessionParameters,
13835 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
13836 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13837 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13838
13839 //=== VK_NVX_binary_import ===
13840
13841 // wrapper function for command vkCreateCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCuModuleNVX.html
13842 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13843 VULKAN_HPP_NODISCARD Result createCuModuleNVX( const CuModuleCreateInfoNVX * pCreateInfo,
13844 const AllocationCallbacks * pAllocator,
13845 CuModuleNVX * pModule,
13846 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13847 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13848 // wrapper function for command vkCreateCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCuModuleNVX.html
13849 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13850 VULKAN_HPP_NODISCARD typename ResultValueType<CuModuleNVX>::type
13851 createCuModuleNVX( const CuModuleCreateInfoNVX & createInfo,
13852 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
13853 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13854 # ifndef VULKAN_HPP_NO_SMART_HANDLE
13855 // wrapper function for command vkCreateCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCuModuleNVX.html
13856 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13857 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<CuModuleNVX, Dispatch>>::type
13858 createCuModuleNVXUnique( const CuModuleCreateInfoNVX & createInfo,
13859 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
13860 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13861 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
13862 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13863
13864 // wrapper function for command vkCreateCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCuFunctionNVX.html
13865 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13866 VULKAN_HPP_NODISCARD Result createCuFunctionNVX( const CuFunctionCreateInfoNVX * pCreateInfo,
13867 const AllocationCallbacks * pAllocator,
13868 CuFunctionNVX * pFunction,
13869 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13870 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13871 // wrapper function for command vkCreateCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCuFunctionNVX.html
13872 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13873 VULKAN_HPP_NODISCARD typename ResultValueType<CuFunctionNVX>::type
13874 createCuFunctionNVX( const CuFunctionCreateInfoNVX & createInfo,
13875 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
13876 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13877 # ifndef VULKAN_HPP_NO_SMART_HANDLE
13878 // wrapper function for command vkCreateCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCuFunctionNVX.html
13879 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13880 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<CuFunctionNVX, Dispatch>>::type
13881 createCuFunctionNVXUnique( const CuFunctionCreateInfoNVX & createInfo,
13882 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
13883 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13884 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
13885 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13886
13887 // wrapper function for command vkDestroyCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCuModuleNVX.html
13888 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13889 void destroyCuModuleNVX( CuModuleNVX module,
13890 const AllocationCallbacks * pAllocator,
13891 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13892 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13893 // wrapper function for command vkDestroyCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCuModuleNVX.html
13894 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13895 void destroyCuModuleNVX( CuModuleNVX module,
13896 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
13897 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13898 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13899
13900 // wrapper function for command vkDestroyCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCuModuleNVX.html
13901 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13902 void destroy( CuModuleNVX module,
13903 const AllocationCallbacks * pAllocator,
13904 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13905 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13906 // wrapper function for command vkDestroyCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCuModuleNVX.html
13907 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13908 void destroy( CuModuleNVX module,
13909 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
13910 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13911 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13912
13913 // wrapper function for command vkDestroyCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCuFunctionNVX.html
13914 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13915 void destroyCuFunctionNVX( CuFunctionNVX function,
13916 const AllocationCallbacks * pAllocator,
13917 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13918 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13919 // wrapper function for command vkDestroyCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCuFunctionNVX.html
13920 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13921 void destroyCuFunctionNVX( CuFunctionNVX function,
13922 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
13923 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13924 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13925
13926 // wrapper function for command vkDestroyCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCuFunctionNVX.html
13927 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13928 void destroy( CuFunctionNVX function,
13929 const AllocationCallbacks * pAllocator,
13930 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13931 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13932 // wrapper function for command vkDestroyCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCuFunctionNVX.html
13933 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13934 void destroy( CuFunctionNVX function,
13935 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
13936 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13937 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13938
13939 //=== VK_NVX_image_view_handle ===
13940
13941 // wrapper function for command vkGetImageViewHandleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewHandleNVX.html
13942 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13943 uint32_t getImageViewHandleNVX( const ImageViewHandleInfoNVX * pInfo,
13944 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13945 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13946 // wrapper function for command vkGetImageViewHandleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewHandleNVX.html
13947 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13948 uint32_t getImageViewHandleNVX( const ImageViewHandleInfoNVX & info,
13949 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13950 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13951
13952 // wrapper function for command vkGetImageViewHandle64NVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewHandle64NVX.html
13953 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13954 uint64_t getImageViewHandle64NVX( const ImageViewHandleInfoNVX * pInfo,
13955 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13956 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13957 // wrapper function for command vkGetImageViewHandle64NVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewHandle64NVX.html
13958 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13959 uint64_t getImageViewHandle64NVX( const ImageViewHandleInfoNVX & info,
13960 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13961 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13962
13963 // wrapper function for command vkGetImageViewAddressNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewAddressNVX.html
13964 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13965 VULKAN_HPP_NODISCARD Result getImageViewAddressNVX( ImageView imageView,
13966 ImageViewAddressPropertiesNVX * pProperties,
13967 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13968 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13969 // wrapper function for command vkGetImageViewAddressNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewAddressNVX.html
13970 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13971 VULKAN_HPP_NODISCARD typename ResultValueType<ImageViewAddressPropertiesNVX>::type
13972 getImageViewAddressNVX( ImageView imageView, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13973 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13974
13975 //=== VK_AMD_shader_info ===
13976
13977 // wrapper function for command vkGetShaderInfoAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderInfoAMD.html
13978 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13979 VULKAN_HPP_NODISCARD Result getShaderInfoAMD( Pipeline pipeline,
13980 ShaderStageFlagBits shaderStage,
13981 ShaderInfoTypeAMD infoType,
13982 size_t * pInfoSize,
13983 void * pInfo,
13984 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13985 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13986 // wrapper function for command vkGetShaderInfoAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderInfoAMD.html
13987 template <typename Uint8_tAllocator = std::allocator<uint8_t>,
13988 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13989 typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0,
13990 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13991 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type getShaderInfoAMD(
13992 Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13993 // wrapper function for command vkGetShaderInfoAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderInfoAMD.html
13994 template <typename Uint8_tAllocator = std::allocator<uint8_t>,
13995 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13996 typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0,
13997 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
13998 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
13999 getShaderInfoAMD( Pipeline pipeline,
14000 ShaderStageFlagBits shaderStage,
14001 ShaderInfoTypeAMD infoType,
14002 Uint8_tAllocator & uint8_tAllocator,
14003 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14004 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14005
14006 #if defined( VK_USE_PLATFORM_WIN32_KHR )
14007 //=== VK_NV_external_memory_win32 ===
14008
14009 // wrapper function for command vkGetMemoryWin32HandleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryWin32HandleNV.html
14010 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14011 VULKAN_HPP_NODISCARD Result getMemoryWin32HandleNV( DeviceMemory memory,
14012 ExternalMemoryHandleTypeFlagsNV handleType,
14013 HANDLE * pHandle,
14014 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14015 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14016 // wrapper function for command vkGetMemoryWin32HandleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryWin32HandleNV.html
14017 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14018 VULKAN_HPP_NODISCARD typename ResultValueType<HANDLE>::type getMemoryWin32HandleNV( DeviceMemory memory,
14019 ExternalMemoryHandleTypeFlagsNV handleType,
14020 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14021 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14022 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
14023
14024 //=== VK_KHR_device_group ===
14025
14026 // wrapper function for command vkGetDeviceGroupPeerMemoryFeaturesKHR, see
14027 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupPeerMemoryFeaturesKHR.html
14028 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14029 void getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex,
14030 uint32_t localDeviceIndex,
14031 uint32_t remoteDeviceIndex,
14032 PeerMemoryFeatureFlags * pPeerMemoryFeatures,
14033 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14034 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14035 // wrapper function for command vkGetDeviceGroupPeerMemoryFeaturesKHR, see
14036 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupPeerMemoryFeaturesKHR.html
14037 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14038 VULKAN_HPP_NODISCARD PeerMemoryFeatureFlags
14039 getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex,
14040 uint32_t localDeviceIndex,
14041 uint32_t remoteDeviceIndex,
14042 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14043 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14044
14045 //=== VK_KHR_maintenance1 ===
14046
14047 // wrapper function for command vkTrimCommandPoolKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkTrimCommandPoolKHR.html
14048 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14049 void trimCommandPoolKHR( CommandPool commandPool,
14050 CommandPoolTrimFlags flags,
14051 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14052
14053 #if defined( VK_USE_PLATFORM_WIN32_KHR )
14054 //=== VK_KHR_external_memory_win32 ===
14055
14056 // wrapper function for command vkGetMemoryWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryWin32HandleKHR.html
14057 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14058 VULKAN_HPP_NODISCARD Result getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR * pGetWin32HandleInfo,
14059 HANDLE * pHandle,
14060 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14061 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14062 // wrapper function for command vkGetMemoryWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryWin32HandleKHR.html
14063 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14064 VULKAN_HPP_NODISCARD typename ResultValueType<HANDLE>::type getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR & getWin32HandleInfo,
14065 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14066 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14067
14068 // wrapper function for command vkGetMemoryWin32HandlePropertiesKHR, see
14069 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryWin32HandlePropertiesKHR.html
14070 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14071 VULKAN_HPP_NODISCARD Result getMemoryWin32HandlePropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType,
14072 HANDLE handle,
14073 MemoryWin32HandlePropertiesKHR * pMemoryWin32HandleProperties,
14074 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14075 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14076 // wrapper function for command vkGetMemoryWin32HandlePropertiesKHR, see
14077 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryWin32HandlePropertiesKHR.html
14078 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14079 VULKAN_HPP_NODISCARD typename ResultValueType<MemoryWin32HandlePropertiesKHR>::type getMemoryWin32HandlePropertiesKHR(
14080 ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14081 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14082 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
14083
14084 //=== VK_KHR_external_memory_fd ===
14085
14086 // wrapper function for command vkGetMemoryFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryFdKHR.html
14087 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14088 VULKAN_HPP_NODISCARD Result getMemoryFdKHR( const MemoryGetFdInfoKHR * pGetFdInfo,
14089 int * pFd,
14090 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14091 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14092 // wrapper function for command vkGetMemoryFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryFdKHR.html
14093 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14094 VULKAN_HPP_NODISCARD typename ResultValueType<int>::type getMemoryFdKHR( const MemoryGetFdInfoKHR & getFdInfo,
14095 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14096 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14097
14098 // wrapper function for command vkGetMemoryFdPropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryFdPropertiesKHR.html
14099 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14100 VULKAN_HPP_NODISCARD Result getMemoryFdPropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType,
14101 int fd,
14102 MemoryFdPropertiesKHR * pMemoryFdProperties,
14103 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14104 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14105 // wrapper function for command vkGetMemoryFdPropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryFdPropertiesKHR.html
14106 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14107 VULKAN_HPP_NODISCARD typename ResultValueType<MemoryFdPropertiesKHR>::type
14108 getMemoryFdPropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, int fd, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14109 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14110
14111 #if defined( VK_USE_PLATFORM_WIN32_KHR )
14112 //=== VK_KHR_external_semaphore_win32 ===
14113
14114 // wrapper function for command vkImportSemaphoreWin32HandleKHR, see
14115 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportSemaphoreWin32HandleKHR.html
14116 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14117 VULKAN_HPP_NODISCARD Result importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR * pImportSemaphoreWin32HandleInfo,
14118 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14119 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14120 // wrapper function for command vkImportSemaphoreWin32HandleKHR, see
14121 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportSemaphoreWin32HandleKHR.html
14122 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14123 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
14124 importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo,
14125 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14126 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14127
14128 // wrapper function for command vkGetSemaphoreWin32HandleKHR, see
14129 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreWin32HandleKHR.html
14130 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14131 VULKAN_HPP_NODISCARD Result getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR * pGetWin32HandleInfo,
14132 HANDLE * pHandle,
14133 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14134 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14135 // wrapper function for command vkGetSemaphoreWin32HandleKHR, see
14136 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreWin32HandleKHR.html
14137 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14138 VULKAN_HPP_NODISCARD typename ResultValueType<HANDLE>::type getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo,
14139 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14140 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14141 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
14142
14143 //=== VK_KHR_external_semaphore_fd ===
14144
14145 // wrapper function for command vkImportSemaphoreFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportSemaphoreFdKHR.html
14146 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14147 VULKAN_HPP_NODISCARD Result importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR * pImportSemaphoreFdInfo,
14148 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14149 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14150 // wrapper function for command vkImportSemaphoreFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportSemaphoreFdKHR.html
14151 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14152 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
14153 importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR & importSemaphoreFdInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14154 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14155
14156 // wrapper function for command vkGetSemaphoreFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreFdKHR.html
14157 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14158 VULKAN_HPP_NODISCARD Result getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR * pGetFdInfo,
14159 int * pFd,
14160 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14161 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14162 // wrapper function for command vkGetSemaphoreFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreFdKHR.html
14163 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14164 VULKAN_HPP_NODISCARD typename ResultValueType<int>::type getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR & getFdInfo,
14165 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14166 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14167
14168 //=== VK_KHR_descriptor_update_template ===
14169
14170 // wrapper function for command vkCreateDescriptorUpdateTemplateKHR, see
14171 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorUpdateTemplateKHR.html
14172 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14173 VULKAN_HPP_NODISCARD Result createDescriptorUpdateTemplateKHR( const DescriptorUpdateTemplateCreateInfo * pCreateInfo,
14174 const AllocationCallbacks * pAllocator,
14175 DescriptorUpdateTemplate * pDescriptorUpdateTemplate,
14176 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14177 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14178 // wrapper function for command vkCreateDescriptorUpdateTemplateKHR, see
14179 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorUpdateTemplateKHR.html
14180 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14181 VULKAN_HPP_NODISCARD typename ResultValueType<DescriptorUpdateTemplate>::type
14182 createDescriptorUpdateTemplateKHR( const DescriptorUpdateTemplateCreateInfo & createInfo,
14183 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
14184 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14185 # ifndef VULKAN_HPP_NO_SMART_HANDLE
14186 // wrapper function for command vkCreateDescriptorUpdateTemplateKHR, see
14187 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorUpdateTemplateKHR.html
14188 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14189 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<DescriptorUpdateTemplate, Dispatch>>::type
14190 createDescriptorUpdateTemplateKHRUnique( const DescriptorUpdateTemplateCreateInfo & createInfo,
14191 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
14192 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14193 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
14194 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14195
14196 // wrapper function for command vkDestroyDescriptorUpdateTemplateKHR, see
14197 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorUpdateTemplateKHR.html
14198 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14199 void destroyDescriptorUpdateTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate,
14200 const AllocationCallbacks * pAllocator,
14201 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14202 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14203 // wrapper function for command vkDestroyDescriptorUpdateTemplateKHR, see
14204 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorUpdateTemplateKHR.html
14205 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14206 void destroyDescriptorUpdateTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
14207 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
14208 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14209 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14210
14211 // wrapper function for command vkUpdateDescriptorSetWithTemplateKHR, see
14212 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateDescriptorSetWithTemplateKHR.html
14213 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14214 void updateDescriptorSetWithTemplateKHR( DescriptorSet descriptorSet,
14215 DescriptorUpdateTemplate descriptorUpdateTemplate,
14216 const void * pData,
14217 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14218 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14219 // wrapper function for command vkUpdateDescriptorSetWithTemplateKHR, see
14220 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateDescriptorSetWithTemplateKHR.html
14221 template <typename DataType,
14222 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14223 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14224 void updateDescriptorSetWithTemplateKHR( DescriptorSet descriptorSet,
14225 DescriptorUpdateTemplate descriptorUpdateTemplate,
14226 DataType const & data,
14227 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14228 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14229
14230 //=== VK_EXT_display_control ===
14231
14232 // wrapper function for command vkDisplayPowerControlEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDisplayPowerControlEXT.html
14233 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14234 VULKAN_HPP_NODISCARD Result displayPowerControlEXT( DisplayKHR display,
14235 const DisplayPowerInfoEXT * pDisplayPowerInfo,
14236 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14237 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14238 // wrapper function for command vkDisplayPowerControlEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDisplayPowerControlEXT.html
14239 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14240 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type displayPowerControlEXT(
14241 DisplayKHR display, const DisplayPowerInfoEXT & displayPowerInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14242 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14243
14244 // wrapper function for command vkRegisterDeviceEventEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterDeviceEventEXT.html
14245 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14246 VULKAN_HPP_NODISCARD Result registerEventEXT( const DeviceEventInfoEXT * pDeviceEventInfo,
14247 const AllocationCallbacks * pAllocator,
14248 Fence * pFence,
14249 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14250 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14251 // wrapper function for command vkRegisterDeviceEventEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterDeviceEventEXT.html
14252 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14253 VULKAN_HPP_NODISCARD typename ResultValueType<Fence>::type
14254 registerEventEXT( const DeviceEventInfoEXT & deviceEventInfo,
14255 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
14256 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14257 # ifndef VULKAN_HPP_NO_SMART_HANDLE
14258 // wrapper function for command vkRegisterDeviceEventEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterDeviceEventEXT.html
14259 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14260 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<Fence, Dispatch>>::type
14261 registerEventEXTUnique( const DeviceEventInfoEXT & deviceEventInfo,
14262 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
14263 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14264 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
14265 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14266
14267 // wrapper function for command vkRegisterDisplayEventEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterDisplayEventEXT.html
14268 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14269 VULKAN_HPP_NODISCARD Result registerDisplayEventEXT( DisplayKHR display,
14270 const DisplayEventInfoEXT * pDisplayEventInfo,
14271 const AllocationCallbacks * pAllocator,
14272 Fence * pFence,
14273 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14274 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14275 // wrapper function for command vkRegisterDisplayEventEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterDisplayEventEXT.html
14276 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14277 VULKAN_HPP_NODISCARD typename ResultValueType<Fence>::type
14278 registerDisplayEventEXT( DisplayKHR display,
14279 const DisplayEventInfoEXT & displayEventInfo,
14280 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
14281 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14282 # ifndef VULKAN_HPP_NO_SMART_HANDLE
14283 // wrapper function for command vkRegisterDisplayEventEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterDisplayEventEXT.html
14284 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14285 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<Fence, Dispatch>>::type
14286 registerDisplayEventEXTUnique( DisplayKHR display,
14287 const DisplayEventInfoEXT & displayEventInfo,
14288 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
14289 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14290 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
14291 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14292
14293 // wrapper function for command vkGetSwapchainCounterEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainCounterEXT.html
14294 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14295 VULKAN_HPP_NODISCARD Result getSwapchainCounterEXT( SwapchainKHR swapchain,
14296 SurfaceCounterFlagBitsEXT counter,
14297 uint64_t * pCounterValue,
14298 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14299 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14300 // wrapper function for command vkGetSwapchainCounterEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainCounterEXT.html
14301 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14302 VULKAN_HPP_NODISCARD
14303 # if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS )
14304 ResultValue<uint64_t>
14305 # else
14306 typename ResultValueType<uint64_t>::type
14307 # endif
14308 getSwapchainCounterEXT( SwapchainKHR swapchain, SurfaceCounterFlagBitsEXT counter, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14309 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14310
14311 //=== VK_GOOGLE_display_timing ===
14312
14313 // wrapper function for command vkGetRefreshCycleDurationGOOGLE, see
14314 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRefreshCycleDurationGOOGLE.html
14315 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14316 VULKAN_HPP_NODISCARD Result getRefreshCycleDurationGOOGLE( SwapchainKHR swapchain,
14317 RefreshCycleDurationGOOGLE * pDisplayTimingProperties,
14318 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14319 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14320 // wrapper function for command vkGetRefreshCycleDurationGOOGLE, see
14321 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRefreshCycleDurationGOOGLE.html
14322 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14323 VULKAN_HPP_NODISCARD typename ResultValueType<RefreshCycleDurationGOOGLE>::type
14324 getRefreshCycleDurationGOOGLE( SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14325 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14326
14327 // wrapper function for command vkGetPastPresentationTimingGOOGLE, see
14328 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPastPresentationTimingGOOGLE.html
14329 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14330 VULKAN_HPP_NODISCARD Result getPastPresentationTimingGOOGLE( SwapchainKHR swapchain,
14331 uint32_t * pPresentationTimingCount,
14332 PastPresentationTimingGOOGLE * pPresentationTimings,
14333 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14334 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14335 // wrapper function for command vkGetPastPresentationTimingGOOGLE, see
14336 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPastPresentationTimingGOOGLE.html
14337 template <
14338 typename PastPresentationTimingGOOGLEAllocator = std::allocator<PastPresentationTimingGOOGLE>,
14339 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14340 typename std::enable_if<std::is_same<typename PastPresentationTimingGOOGLEAllocator::value_type, PastPresentationTimingGOOGLE>::value, int>::type = 0,
14341 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14342 VULKAN_HPP_NODISCARD
14343 # if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS )
14344 ResultValue<std::vector<PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator>>
14345 # else
14346 typename ResultValueType<std::vector<PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator>>::type
14347 # endif
14348 getPastPresentationTimingGOOGLE( SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14349 // wrapper function for command vkGetPastPresentationTimingGOOGLE, see
14350 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPastPresentationTimingGOOGLE.html
14351 template <
14352 typename PastPresentationTimingGOOGLEAllocator = std::allocator<PastPresentationTimingGOOGLE>,
14353 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14354 typename std::enable_if<std::is_same<typename PastPresentationTimingGOOGLEAllocator::value_type, PastPresentationTimingGOOGLE>::value, int>::type = 0,
14355 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14356 VULKAN_HPP_NODISCARD
14357 # if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS )
14358 ResultValue<std::vector<PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator>>
14359 # else
14360 typename ResultValueType<std::vector<PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator>>::type
14361 # endif
14362 getPastPresentationTimingGOOGLE( SwapchainKHR swapchain,
14363 PastPresentationTimingGOOGLEAllocator & pastPresentationTimingGOOGLEAllocator,
14364 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14365 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14366
14367 //=== VK_EXT_hdr_metadata ===
14368
14369 // wrapper function for command vkSetHdrMetadataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetHdrMetadataEXT.html
14370 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14371 void setHdrMetadataEXT( uint32_t swapchainCount,
14372 const SwapchainKHR * pSwapchains,
14373 const HdrMetadataEXT * pMetadata,
14374 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14375 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14376 // wrapper function for command vkSetHdrMetadataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetHdrMetadataEXT.html
14377 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14378 void setHdrMetadataEXT( ArrayProxy<const SwapchainKHR> const & swapchains,
14379 ArrayProxy<const HdrMetadataEXT> const & metadata,
14380 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
14381 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14382
14383 //=== VK_KHR_create_renderpass2 ===
14384
14385 // wrapper function for command vkCreateRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass2KHR.html
14386 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14387 VULKAN_HPP_NODISCARD Result createRenderPass2KHR( const RenderPassCreateInfo2 * pCreateInfo,
14388 const AllocationCallbacks * pAllocator,
14389 RenderPass * pRenderPass,
14390 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14391 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14392 // wrapper function for command vkCreateRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass2KHR.html
14393 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14394 VULKAN_HPP_NODISCARD typename ResultValueType<RenderPass>::type
14395 createRenderPass2KHR( const RenderPassCreateInfo2 & createInfo,
14396 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
14397 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14398 # ifndef VULKAN_HPP_NO_SMART_HANDLE
14399 // wrapper function for command vkCreateRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass2KHR.html
14400 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14401 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<RenderPass, Dispatch>>::type
14402 createRenderPass2KHRUnique( const RenderPassCreateInfo2 & createInfo,
14403 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
14404 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14405 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
14406 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14407
14408 //=== VK_KHR_shared_presentable_image ===
14409
14410 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
14411 // wrapper function for command vkGetSwapchainStatusKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainStatusKHR.html
14412 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14413 VULKAN_HPP_NODISCARD Result getSwapchainStatusKHR( SwapchainKHR swapchain,
14414 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14415 #else
14416 // wrapper function for command vkGetSwapchainStatusKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainStatusKHR.html
14417 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14418 VULKAN_HPP_NODISCARD Result getSwapchainStatusKHR( SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14419 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
14420
14421 #if defined( VK_USE_PLATFORM_WIN32_KHR )
14422 //=== VK_KHR_external_fence_win32 ===
14423
14424 // wrapper function for command vkImportFenceWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportFenceWin32HandleKHR.html
14425 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14426 VULKAN_HPP_NODISCARD Result importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR * pImportFenceWin32HandleInfo,
14427 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14428 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14429 // wrapper function for command vkImportFenceWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportFenceWin32HandleKHR.html
14430 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14431 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
14432 importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo,
14433 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14434 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14435
14436 // wrapper function for command vkGetFenceWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFenceWin32HandleKHR.html
14437 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14438 VULKAN_HPP_NODISCARD Result getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR * pGetWin32HandleInfo,
14439 HANDLE * pHandle,
14440 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14441 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14442 // wrapper function for command vkGetFenceWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFenceWin32HandleKHR.html
14443 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14444 VULKAN_HPP_NODISCARD typename ResultValueType<HANDLE>::type getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR & getWin32HandleInfo,
14445 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14446 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14447 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
14448
14449 //=== VK_KHR_external_fence_fd ===
14450
14451 // wrapper function for command vkImportFenceFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportFenceFdKHR.html
14452 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14453 VULKAN_HPP_NODISCARD Result importFenceFdKHR( const ImportFenceFdInfoKHR * pImportFenceFdInfo,
14454 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14455 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14456 // wrapper function for command vkImportFenceFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportFenceFdKHR.html
14457 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14458 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
14459 importFenceFdKHR( const ImportFenceFdInfoKHR & importFenceFdInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14460 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14461
14462 // wrapper function for command vkGetFenceFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFenceFdKHR.html
14463 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14464 VULKAN_HPP_NODISCARD Result getFenceFdKHR( const FenceGetFdInfoKHR * pGetFdInfo,
14465 int * pFd,
14466 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14467 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14468 // wrapper function for command vkGetFenceFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFenceFdKHR.html
14469 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14470 VULKAN_HPP_NODISCARD typename ResultValueType<int>::type getFenceFdKHR( const FenceGetFdInfoKHR & getFdInfo,
14471 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14472 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14473
14474 //=== VK_KHR_performance_query ===
14475
14476 // wrapper function for command vkAcquireProfilingLockKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireProfilingLockKHR.html
14477 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14478 VULKAN_HPP_NODISCARD Result acquireProfilingLockKHR( const AcquireProfilingLockInfoKHR * pInfo,
14479 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14480 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14481 // wrapper function for command vkAcquireProfilingLockKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireProfilingLockKHR.html
14482 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14483 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
14484 acquireProfilingLockKHR( const AcquireProfilingLockInfoKHR & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14485 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14486
14487 // wrapper function for command vkReleaseProfilingLockKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseProfilingLockKHR.html
14488 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14489 void releaseProfilingLockKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14490
14491 //=== VK_EXT_debug_utils ===
14492
14493 // wrapper function for command vkSetDebugUtilsObjectNameEXT, see
14494 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDebugUtilsObjectNameEXT.html
14495 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14496 VULKAN_HPP_NODISCARD Result setDebugUtilsObjectNameEXT( const DebugUtilsObjectNameInfoEXT * pNameInfo,
14497 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14498 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14499 // wrapper function for command vkSetDebugUtilsObjectNameEXT, see
14500 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDebugUtilsObjectNameEXT.html
14501 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14502 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
14503 setDebugUtilsObjectNameEXT( const DebugUtilsObjectNameInfoEXT & nameInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14504 // wrapper function for command vkSetDebugUtilsObjectNameEXT, see
14505 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDebugUtilsObjectNameEXT.html
14506 template <typename HandleType,
14507 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14508 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14509 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
14510 setDebugUtilsObjectNameEXT( HandleType const & handle, std::string const & name, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14511 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14512
14513 // wrapper function for command vkSetDebugUtilsObjectTagEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDebugUtilsObjectTagEXT.html
14514 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14515 VULKAN_HPP_NODISCARD Result setDebugUtilsObjectTagEXT( const DebugUtilsObjectTagInfoEXT * pTagInfo,
14516 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14517 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14518 // wrapper function for command vkSetDebugUtilsObjectTagEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDebugUtilsObjectTagEXT.html
14519 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14520 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
14521 setDebugUtilsObjectTagEXT( const DebugUtilsObjectTagInfoEXT & tagInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14522 // wrapper function for command vkSetDebugUtilsObjectTagEXT, see
14523 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDebugUtilsObjectTagEXT.html
14524 template <typename HandleType,
14525 typename TagType,
14526 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14527 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14528 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type setDebugUtilsObjectTagEXT(
14529 HandleType const & handle, uint64_t name, TagType const & tag, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14530 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14531
14532 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
14533 //=== VK_ANDROID_external_memory_android_hardware_buffer ===
14534
14535 // wrapper function for command vkGetAndroidHardwareBufferPropertiesANDROID, see
14536 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAndroidHardwareBufferPropertiesANDROID.html
14537 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14538 VULKAN_HPP_NODISCARD Result
14539 getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer * buffer,
14540 AndroidHardwareBufferPropertiesANDROID * pProperties,
14541 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14542 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14543 // wrapper function for command vkGetAndroidHardwareBufferPropertiesANDROID, see
14544 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAndroidHardwareBufferPropertiesANDROID.html
14545 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14546 VULKAN_HPP_NODISCARD typename ResultValueType<AndroidHardwareBufferPropertiesANDROID>::type
14547 getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14548 // wrapper function for command vkGetAndroidHardwareBufferPropertiesANDROID, see
14549 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAndroidHardwareBufferPropertiesANDROID.html
14550 template <typename X,
14551 typename Y,
14552 typename... Z,
14553 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14554 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14555 VULKAN_HPP_NODISCARD typename ResultValueType<StructureChain<X, Y, Z...>>::type
14556 getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14557 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14558
14559 // wrapper function for command vkGetMemoryAndroidHardwareBufferANDROID, see
14560 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryAndroidHardwareBufferANDROID.html
14561 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14562 VULKAN_HPP_NODISCARD Result getMemoryAndroidHardwareBufferANDROID( const MemoryGetAndroidHardwareBufferInfoANDROID * pInfo,
14563 struct AHardwareBuffer ** pBuffer,
14564 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14565 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14566 // wrapper function for command vkGetMemoryAndroidHardwareBufferANDROID, see
14567 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryAndroidHardwareBufferANDROID.html
14568 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14569 VULKAN_HPP_NODISCARD typename ResultValueType<struct AHardwareBuffer *>::type
14570 getMemoryAndroidHardwareBufferANDROID( const MemoryGetAndroidHardwareBufferInfoANDROID & info,
14571 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14572 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14573 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
14574
14575 #if defined( VK_ENABLE_BETA_EXTENSIONS )
14576 //=== VK_AMDX_shader_enqueue ===
14577
14578 // wrapper function for command vkCreateExecutionGraphPipelinesAMDX, see
14579 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExecutionGraphPipelinesAMDX.html
14580 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14581 VULKAN_HPP_NODISCARD Result createExecutionGraphPipelinesAMDX( PipelineCache pipelineCache,
14582 uint32_t createInfoCount,
14583 const ExecutionGraphPipelineCreateInfoAMDX * pCreateInfos,
14584 const AllocationCallbacks * pAllocator,
14585 Pipeline * pPipelines,
14586 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14587 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14588 // wrapper function for command vkCreateExecutionGraphPipelinesAMDX, see
14589 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExecutionGraphPipelinesAMDX.html
14590 template <typename PipelineAllocator = std::allocator<Pipeline>,
14591 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14592 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, Pipeline>::value, int>::type = 0,
14593 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14594 VULKAN_HPP_NODISCARD ResultValue<std::vector<Pipeline, PipelineAllocator>>
14595 createExecutionGraphPipelinesAMDX( PipelineCache pipelineCache,
14596 ArrayProxy<const ExecutionGraphPipelineCreateInfoAMDX> const & createInfos,
14597 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
14598 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14599 // wrapper function for command vkCreateExecutionGraphPipelinesAMDX, see
14600 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExecutionGraphPipelinesAMDX.html
14601 template <typename PipelineAllocator = std::allocator<Pipeline>,
14602 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14603 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, Pipeline>::value, int>::type = 0,
14604 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14605 VULKAN_HPP_NODISCARD ResultValue<std::vector<Pipeline, PipelineAllocator>>
14606 createExecutionGraphPipelinesAMDX( PipelineCache pipelineCache,
14607 ArrayProxy<const ExecutionGraphPipelineCreateInfoAMDX> const & createInfos,
14608 Optional<const AllocationCallbacks> allocator,
14609 PipelineAllocator & pipelineAllocator,
14610 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14611 // wrapper function for command vkCreateExecutionGraphPipelinesAMDX, see
14612 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExecutionGraphPipelinesAMDX.html
14613 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14614 VULKAN_HPP_NODISCARD ResultValue<Pipeline>
14615 createExecutionGraphPipelineAMDX( PipelineCache pipelineCache,
14616 const ExecutionGraphPipelineCreateInfoAMDX & createInfo,
14617 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
14618 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14619 # ifndef VULKAN_HPP_NO_SMART_HANDLE
14620 // wrapper function for command vkCreateExecutionGraphPipelinesAMDX, see
14621 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExecutionGraphPipelinesAMDX.html
14622 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14623 typename PipelineAllocator = std::allocator<UniqueHandle<Pipeline, Dispatch>>,
14624 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<Pipeline, Dispatch>>::value, int>::type = 0,
14625 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14626 VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
14627 createExecutionGraphPipelinesAMDXUnique( PipelineCache pipelineCache,
14628 ArrayProxy<const ExecutionGraphPipelineCreateInfoAMDX> const & createInfos,
14629 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
14630 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14631 // wrapper function for command vkCreateExecutionGraphPipelinesAMDX, see
14632 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExecutionGraphPipelinesAMDX.html
14633 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14634 typename PipelineAllocator = std::allocator<UniqueHandle<Pipeline, Dispatch>>,
14635 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<Pipeline, Dispatch>>::value, int>::type = 0,
14636 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14637 VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
14638 createExecutionGraphPipelinesAMDXUnique( PipelineCache pipelineCache,
14639 ArrayProxy<const ExecutionGraphPipelineCreateInfoAMDX> const & createInfos,
14640 Optional<const AllocationCallbacks> allocator,
14641 PipelineAllocator & pipelineAllocator,
14642 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14643 // wrapper function for command vkCreateExecutionGraphPipelinesAMDX, see
14644 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExecutionGraphPipelinesAMDX.html
14645 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14646 VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<Pipeline, Dispatch>>
14647 createExecutionGraphPipelineAMDXUnique( PipelineCache pipelineCache,
14648 const ExecutionGraphPipelineCreateInfoAMDX & createInfo,
14649 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
14650 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14651 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
14652 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14653
14654 // wrapper function for command vkGetExecutionGraphPipelineScratchSizeAMDX, see
14655 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExecutionGraphPipelineScratchSizeAMDX.html
14656 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14657 VULKAN_HPP_NODISCARD Result
14658 getExecutionGraphPipelineScratchSizeAMDX( Pipeline executionGraph,
14659 ExecutionGraphPipelineScratchSizeAMDX * pSizeInfo,
14660 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14661 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14662 // wrapper function for command vkGetExecutionGraphPipelineScratchSizeAMDX, see
14663 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExecutionGraphPipelineScratchSizeAMDX.html
14664 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14665 VULKAN_HPP_NODISCARD typename ResultValueType<ExecutionGraphPipelineScratchSizeAMDX>::type
14666 getExecutionGraphPipelineScratchSizeAMDX( Pipeline executionGraph, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14667 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14668
14669 // wrapper function for command vkGetExecutionGraphPipelineNodeIndexAMDX, see
14670 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExecutionGraphPipelineNodeIndexAMDX.html
14671 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14672 VULKAN_HPP_NODISCARD Result getExecutionGraphPipelineNodeIndexAMDX( Pipeline executionGraph,
14673 const PipelineShaderStageNodeCreateInfoAMDX * pNodeInfo,
14674 uint32_t * pNodeIndex,
14675 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14676 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14677 // wrapper function for command vkGetExecutionGraphPipelineNodeIndexAMDX, see
14678 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExecutionGraphPipelineNodeIndexAMDX.html
14679 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14680 VULKAN_HPP_NODISCARD typename ResultValueType<uint32_t>::type getExecutionGraphPipelineNodeIndexAMDX(
14681 Pipeline executionGraph, const PipelineShaderStageNodeCreateInfoAMDX & nodeInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14682 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14683 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
14684
14685 //=== VK_KHR_get_memory_requirements2 ===
14686
14687 // wrapper function for command vkGetImageMemoryRequirements2KHR, see
14688 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements2KHR.html
14689 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14690 void getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 * pInfo,
14691 MemoryRequirements2 * pMemoryRequirements,
14692 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14693 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14694 // wrapper function for command vkGetImageMemoryRequirements2KHR, see
14695 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements2KHR.html
14696 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14697 VULKAN_HPP_NODISCARD MemoryRequirements2 getImageMemoryRequirements2KHR(
14698 const ImageMemoryRequirementsInfo2 & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14699 // wrapper function for command vkGetImageMemoryRequirements2KHR, see
14700 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements2KHR.html
14701 template <typename X,
14702 typename Y,
14703 typename... Z,
14704 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14705 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14706 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
14707 getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info,
14708 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14709 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14710
14711 // wrapper function for command vkGetBufferMemoryRequirements2KHR, see
14712 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements2KHR.html
14713 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14714 void getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 * pInfo,
14715 MemoryRequirements2 * pMemoryRequirements,
14716 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14717 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14718 // wrapper function for command vkGetBufferMemoryRequirements2KHR, see
14719 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements2KHR.html
14720 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14721 VULKAN_HPP_NODISCARD MemoryRequirements2 getBufferMemoryRequirements2KHR(
14722 const BufferMemoryRequirementsInfo2 & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14723 // wrapper function for command vkGetBufferMemoryRequirements2KHR, see
14724 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements2KHR.html
14725 template <typename X,
14726 typename Y,
14727 typename... Z,
14728 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14729 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14730 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
14731 getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info,
14732 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14733 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14734
14735 // wrapper function for command vkGetImageSparseMemoryRequirements2KHR, see
14736 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements2KHR.html
14737 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14738 void getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 * pInfo,
14739 uint32_t * pSparseMemoryRequirementCount,
14740 SparseImageMemoryRequirements2 * pSparseMemoryRequirements,
14741 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14742 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14743 // wrapper function for command vkGetImageSparseMemoryRequirements2KHR, see
14744 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements2KHR.html
14745 template <
14746 typename SparseImageMemoryRequirements2Allocator = std::allocator<SparseImageMemoryRequirements2>,
14747 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14748 typename std::enable_if<std::is_same<typename SparseImageMemoryRequirements2Allocator::value_type, SparseImageMemoryRequirements2>::value, int>::type = 0,
14749 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14750 VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
14751 getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info,
14752 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14753 // wrapper function for command vkGetImageSparseMemoryRequirements2KHR, see
14754 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements2KHR.html
14755 template <
14756 typename SparseImageMemoryRequirements2Allocator = std::allocator<SparseImageMemoryRequirements2>,
14757 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14758 typename std::enable_if<std::is_same<typename SparseImageMemoryRequirements2Allocator::value_type, SparseImageMemoryRequirements2>::value, int>::type = 0,
14759 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14760 VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
14761 getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info,
14762 SparseImageMemoryRequirements2Allocator & sparseImageMemoryRequirements2Allocator,
14763 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14764 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14765
14766 //=== VK_KHR_acceleration_structure ===
14767
14768 // wrapper function for command vkCreateAccelerationStructureKHR, see
14769 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAccelerationStructureKHR.html
14770 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14771 VULKAN_HPP_NODISCARD Result createAccelerationStructureKHR( const AccelerationStructureCreateInfoKHR * pCreateInfo,
14772 const AllocationCallbacks * pAllocator,
14773 AccelerationStructureKHR * pAccelerationStructure,
14774 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14775 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14776 // wrapper function for command vkCreateAccelerationStructureKHR, see
14777 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAccelerationStructureKHR.html
14778 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14779 VULKAN_HPP_NODISCARD typename ResultValueType<AccelerationStructureKHR>::type
14780 createAccelerationStructureKHR( const AccelerationStructureCreateInfoKHR & createInfo,
14781 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
14782 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14783 # ifndef VULKAN_HPP_NO_SMART_HANDLE
14784 // wrapper function for command vkCreateAccelerationStructureKHR, see
14785 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAccelerationStructureKHR.html
14786 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14787 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<AccelerationStructureKHR, Dispatch>>::type
14788 createAccelerationStructureKHRUnique( const AccelerationStructureCreateInfoKHR & createInfo,
14789 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
14790 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14791 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
14792 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14793
14794 // wrapper function for command vkDestroyAccelerationStructureKHR, see
14795 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyAccelerationStructureKHR.html
14796 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14797 void destroyAccelerationStructureKHR( AccelerationStructureKHR accelerationStructure,
14798 const AllocationCallbacks * pAllocator,
14799 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14800 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14801 // wrapper function for command vkDestroyAccelerationStructureKHR, see
14802 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyAccelerationStructureKHR.html
14803 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14804 void destroyAccelerationStructureKHR( AccelerationStructureKHR accelerationStructure VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
14805 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
14806 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14807 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14808
14809 // wrapper function for command vkDestroyAccelerationStructureKHR, see
14810 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyAccelerationStructureKHR.html
14811 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14812 void destroy( AccelerationStructureKHR accelerationStructure,
14813 const AllocationCallbacks * pAllocator,
14814 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14815 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14816 // wrapper function for command vkDestroyAccelerationStructureKHR, see
14817 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyAccelerationStructureKHR.html
14818 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14819 void destroy( AccelerationStructureKHR accelerationStructure,
14820 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
14821 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14822 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14823
14824 // wrapper function for command vkBuildAccelerationStructuresKHR, see
14825 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBuildAccelerationStructuresKHR.html
14826 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14827 VULKAN_HPP_NODISCARD Result buildAccelerationStructuresKHR( DeferredOperationKHR deferredOperation,
14828 uint32_t infoCount,
14829 const AccelerationStructureBuildGeometryInfoKHR * pInfos,
14830 const AccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos,
14831 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14832 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14833 // wrapper function for command vkBuildAccelerationStructuresKHR, see
14834 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBuildAccelerationStructuresKHR.html
14835 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14836 VULKAN_HPP_NODISCARD Result buildAccelerationStructuresKHR( DeferredOperationKHR deferredOperation,
14837 ArrayProxy<const AccelerationStructureBuildGeometryInfoKHR> const & infos,
14838 ArrayProxy<const AccelerationStructureBuildRangeInfoKHR * const> const & pBuildRangeInfos,
14839 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14840 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14841
14842 // wrapper function for command vkCopyAccelerationStructureKHR, see
14843 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyAccelerationStructureKHR.html
14844 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14845 VULKAN_HPP_NODISCARD Result copyAccelerationStructureKHR( DeferredOperationKHR deferredOperation,
14846 const CopyAccelerationStructureInfoKHR * pInfo,
14847 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14848 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14849 // wrapper function for command vkCopyAccelerationStructureKHR, see
14850 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyAccelerationStructureKHR.html
14851 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14852 VULKAN_HPP_NODISCARD Result copyAccelerationStructureKHR( DeferredOperationKHR deferredOperation,
14853 const CopyAccelerationStructureInfoKHR & info,
14854 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14855 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14856
14857 // wrapper function for command vkCopyAccelerationStructureToMemoryKHR, see
14858 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyAccelerationStructureToMemoryKHR.html
14859 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14860 VULKAN_HPP_NODISCARD Result copyAccelerationStructureToMemoryKHR( DeferredOperationKHR deferredOperation,
14861 const CopyAccelerationStructureToMemoryInfoKHR * pInfo,
14862 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14863 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14864 // wrapper function for command vkCopyAccelerationStructureToMemoryKHR, see
14865 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyAccelerationStructureToMemoryKHR.html
14866 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14867 VULKAN_HPP_NODISCARD Result copyAccelerationStructureToMemoryKHR( DeferredOperationKHR deferredOperation,
14868 const CopyAccelerationStructureToMemoryInfoKHR & info,
14869 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14870 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14871
14872 // wrapper function for command vkCopyMemoryToAccelerationStructureKHR, see
14873 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToAccelerationStructureKHR.html
14874 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14875 VULKAN_HPP_NODISCARD Result copyMemoryToAccelerationStructureKHR( DeferredOperationKHR deferredOperation,
14876 const CopyMemoryToAccelerationStructureInfoKHR * pInfo,
14877 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14878 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14879 // wrapper function for command vkCopyMemoryToAccelerationStructureKHR, see
14880 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToAccelerationStructureKHR.html
14881 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14882 VULKAN_HPP_NODISCARD Result copyMemoryToAccelerationStructureKHR( DeferredOperationKHR deferredOperation,
14883 const CopyMemoryToAccelerationStructureInfoKHR & info,
14884 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14885 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14886
14887 // wrapper function for command vkWriteAccelerationStructuresPropertiesKHR, see
14888 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteAccelerationStructuresPropertiesKHR.html
14889 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14890 VULKAN_HPP_NODISCARD Result
14891 writeAccelerationStructuresPropertiesKHR( uint32_t accelerationStructureCount,
14892 const AccelerationStructureKHR * pAccelerationStructures,
14893 QueryType queryType,
14894 size_t dataSize,
14895 void * pData,
14896 size_t stride,
14897 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14898 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14899 // wrapper function for command vkWriteAccelerationStructuresPropertiesKHR, see
14900 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteAccelerationStructuresPropertiesKHR.html
14901 template <typename DataType,
14902 typename DataTypeAllocator = std::allocator<DataType>,
14903 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14904 typename std::enable_if<std::is_same<typename DataTypeAllocator::value_type, DataType>::value, int>::type = 0,
14905 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14906 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type
14907 writeAccelerationStructuresPropertiesKHR( ArrayProxy<const AccelerationStructureKHR> const & accelerationStructures,
14908 QueryType queryType,
14909 size_t dataSize,
14910 size_t stride,
14911 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14912 // wrapper function for command vkWriteAccelerationStructuresPropertiesKHR, see
14913 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteAccelerationStructuresPropertiesKHR.html
14914 template <typename DataType,
14915 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14916 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14917 VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type
14918 writeAccelerationStructuresPropertyKHR( ArrayProxy<const AccelerationStructureKHR> const & accelerationStructures,
14919 QueryType queryType,
14920 size_t stride,
14921 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14922 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14923
14924 // wrapper function for command vkGetAccelerationStructureDeviceAddressKHR, see
14925 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureDeviceAddressKHR.html
14926 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14927 DeviceAddress getAccelerationStructureAddressKHR( const AccelerationStructureDeviceAddressInfoKHR * pInfo,
14928 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14929 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14930 // wrapper function for command vkGetAccelerationStructureDeviceAddressKHR, see
14931 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureDeviceAddressKHR.html
14932 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14933 DeviceAddress getAccelerationStructureAddressKHR( const AccelerationStructureDeviceAddressInfoKHR & info,
14934 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14935 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14936
14937 // wrapper function for command vkGetDeviceAccelerationStructureCompatibilityKHR, see
14938 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceAccelerationStructureCompatibilityKHR.html
14939 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14940 void getAccelerationStructureCompatibilityKHR( const AccelerationStructureVersionInfoKHR * pVersionInfo,
14941 AccelerationStructureCompatibilityKHR * pCompatibility,
14942 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14943 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14944 // wrapper function for command vkGetDeviceAccelerationStructureCompatibilityKHR, see
14945 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceAccelerationStructureCompatibilityKHR.html
14946 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14947 VULKAN_HPP_NODISCARD AccelerationStructureCompatibilityKHR getAccelerationStructureCompatibilityKHR(
14948 const AccelerationStructureVersionInfoKHR & versionInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14949 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14950
14951 // wrapper function for command vkGetAccelerationStructureBuildSizesKHR, see
14952 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureBuildSizesKHR.html
14953 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14954 void getAccelerationStructureBuildSizesKHR( AccelerationStructureBuildTypeKHR buildType,
14955 const AccelerationStructureBuildGeometryInfoKHR * pBuildInfo,
14956 const uint32_t * pMaxPrimitiveCounts,
14957 AccelerationStructureBuildSizesInfoKHR * pSizeInfo,
14958 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14959 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14960 // wrapper function for command vkGetAccelerationStructureBuildSizesKHR, see
14961 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureBuildSizesKHR.html
14962 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14963 VULKAN_HPP_NODISCARD AccelerationStructureBuildSizesInfoKHR
14964 getAccelerationStructureBuildSizesKHR( AccelerationStructureBuildTypeKHR buildType,
14965 const AccelerationStructureBuildGeometryInfoKHR & buildInfo,
14966 ArrayProxy<const uint32_t> const & maxPrimitiveCounts VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
14967 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
14968 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14969
14970 //=== VK_KHR_ray_tracing_pipeline ===
14971
14972 // wrapper function for command vkCreateRayTracingPipelinesKHR, see
14973 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesKHR.html
14974 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14975 VULKAN_HPP_NODISCARD Result createRayTracingPipelinesKHR( DeferredOperationKHR deferredOperation,
14976 PipelineCache pipelineCache,
14977 uint32_t createInfoCount,
14978 const RayTracingPipelineCreateInfoKHR * pCreateInfos,
14979 const AllocationCallbacks * pAllocator,
14980 Pipeline * pPipelines,
14981 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14982 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14983 // wrapper function for command vkCreateRayTracingPipelinesKHR, see
14984 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesKHR.html
14985 template <typename PipelineAllocator = std::allocator<Pipeline>,
14986 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14987 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, Pipeline>::value, int>::type = 0,
14988 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
14989 VULKAN_HPP_NODISCARD ResultValue<std::vector<Pipeline, PipelineAllocator>>
14990 createRayTracingPipelinesKHR( DeferredOperationKHR deferredOperation,
14991 PipelineCache pipelineCache,
14992 ArrayProxy<const RayTracingPipelineCreateInfoKHR> const & createInfos,
14993 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
14994 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14995 // wrapper function for command vkCreateRayTracingPipelinesKHR, see
14996 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesKHR.html
14997 template <typename PipelineAllocator = std::allocator<Pipeline>,
14998 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14999 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, Pipeline>::value, int>::type = 0,
15000 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15001 VULKAN_HPP_NODISCARD ResultValue<std::vector<Pipeline, PipelineAllocator>>
15002 createRayTracingPipelinesKHR( DeferredOperationKHR deferredOperation,
15003 PipelineCache pipelineCache,
15004 ArrayProxy<const RayTracingPipelineCreateInfoKHR> const & createInfos,
15005 Optional<const AllocationCallbacks> allocator,
15006 PipelineAllocator & pipelineAllocator,
15007 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15008 // wrapper function for command vkCreateRayTracingPipelinesKHR, see
15009 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesKHR.html
15010 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15011 VULKAN_HPP_NODISCARD ResultValue<Pipeline>
15012 createRayTracingPipelineKHR( DeferredOperationKHR deferredOperation,
15013 PipelineCache pipelineCache,
15014 const RayTracingPipelineCreateInfoKHR & createInfo,
15015 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
15016 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15017 # ifndef VULKAN_HPP_NO_SMART_HANDLE
15018 // wrapper function for command vkCreateRayTracingPipelinesKHR, see
15019 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesKHR.html
15020 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15021 typename PipelineAllocator = std::allocator<UniqueHandle<Pipeline, Dispatch>>,
15022 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<Pipeline, Dispatch>>::value, int>::type = 0,
15023 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15024 VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
15025 createRayTracingPipelinesKHRUnique( DeferredOperationKHR deferredOperation,
15026 PipelineCache pipelineCache,
15027 ArrayProxy<const RayTracingPipelineCreateInfoKHR> const & createInfos,
15028 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
15029 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15030 // wrapper function for command vkCreateRayTracingPipelinesKHR, see
15031 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesKHR.html
15032 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15033 typename PipelineAllocator = std::allocator<UniqueHandle<Pipeline, Dispatch>>,
15034 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<Pipeline, Dispatch>>::value, int>::type = 0,
15035 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15036 VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
15037 createRayTracingPipelinesKHRUnique( DeferredOperationKHR deferredOperation,
15038 PipelineCache pipelineCache,
15039 ArrayProxy<const RayTracingPipelineCreateInfoKHR> const & createInfos,
15040 Optional<const AllocationCallbacks> allocator,
15041 PipelineAllocator & pipelineAllocator,
15042 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15043 // wrapper function for command vkCreateRayTracingPipelinesKHR, see
15044 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesKHR.html
15045 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15046 VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<Pipeline, Dispatch>>
15047 createRayTracingPipelineKHRUnique( DeferredOperationKHR deferredOperation,
15048 PipelineCache pipelineCache,
15049 const RayTracingPipelineCreateInfoKHR & createInfo,
15050 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
15051 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15052 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
15053 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15054
15055 // wrapper function for command vkGetRayTracingShaderGroupHandlesKHR, see
15056 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupHandlesKHR.html
15057 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15058 VULKAN_HPP_NODISCARD Result getRayTracingShaderGroupHandlesKHR( Pipeline pipeline,
15059 uint32_t firstGroup,
15060 uint32_t groupCount,
15061 size_t dataSize,
15062 void * pData,
15063 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15064 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15065 // wrapper function for command vkGetRayTracingShaderGroupHandlesKHR, see
15066 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupHandlesKHR.html
15067 template <typename DataType,
15068 typename DataTypeAllocator = std::allocator<DataType>,
15069 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15070 typename std::enable_if<std::is_same<typename DataTypeAllocator::value_type, DataType>::value, int>::type = 0,
15071 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15072 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type getRayTracingShaderGroupHandlesKHR(
15073 Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15074 // wrapper function for command vkGetRayTracingShaderGroupHandlesKHR, see
15075 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupHandlesKHR.html
15076 template <typename DataType,
15077 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15078 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15079 VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type getRayTracingShaderGroupHandleKHR(
15080 Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15081 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15082
15083 // wrapper function for command vkGetRayTracingCaptureReplayShaderGroupHandlesKHR, see
15084 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingCaptureReplayShaderGroupHandlesKHR.html
15085 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15086 VULKAN_HPP_NODISCARD Result getRayTracingCaptureReplayShaderGroupHandlesKHR(
15087 Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void * pData, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT )
15088 const VULKAN_HPP_NOEXCEPT;
15089 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15090 // wrapper function for command vkGetRayTracingCaptureReplayShaderGroupHandlesKHR, see
15091 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingCaptureReplayShaderGroupHandlesKHR.html
15092 template <typename DataType,
15093 typename DataTypeAllocator = std::allocator<DataType>,
15094 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15095 typename std::enable_if<std::is_same<typename DataTypeAllocator::value_type, DataType>::value, int>::type = 0,
15096 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15097 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type getRayTracingCaptureReplayShaderGroupHandlesKHR(
15098 Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15099 // wrapper function for command vkGetRayTracingCaptureReplayShaderGroupHandlesKHR, see
15100 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingCaptureReplayShaderGroupHandlesKHR.html
15101 template <typename DataType,
15102 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15103 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15104 VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type getRayTracingCaptureReplayShaderGroupHandleKHR(
15105 Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15106 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15107
15108 // wrapper function for command vkGetRayTracingShaderGroupStackSizeKHR, see
15109 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupStackSizeKHR.html
15110 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15111 DeviceSize getRayTracingShaderGroupStackSizeKHR( Pipeline pipeline,
15112 uint32_t group,
15113 ShaderGroupShaderKHR groupShader,
15114 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15115
15116 //=== VK_KHR_sampler_ycbcr_conversion ===
15117
15118 // wrapper function for command vkCreateSamplerYcbcrConversionKHR, see
15119 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSamplerYcbcrConversionKHR.html
15120 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15121 VULKAN_HPP_NODISCARD Result createSamplerYcbcrConversionKHR( const SamplerYcbcrConversionCreateInfo * pCreateInfo,
15122 const AllocationCallbacks * pAllocator,
15123 SamplerYcbcrConversion * pYcbcrConversion,
15124 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15125 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15126 // wrapper function for command vkCreateSamplerYcbcrConversionKHR, see
15127 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSamplerYcbcrConversionKHR.html
15128 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15129 VULKAN_HPP_NODISCARD typename ResultValueType<SamplerYcbcrConversion>::type
15130 createSamplerYcbcrConversionKHR( const SamplerYcbcrConversionCreateInfo & createInfo,
15131 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
15132 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15133 # ifndef VULKAN_HPP_NO_SMART_HANDLE
15134 // wrapper function for command vkCreateSamplerYcbcrConversionKHR, see
15135 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSamplerYcbcrConversionKHR.html
15136 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15137 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<SamplerYcbcrConversion, Dispatch>>::type
15138 createSamplerYcbcrConversionKHRUnique( const SamplerYcbcrConversionCreateInfo & createInfo,
15139 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
15140 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15141 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
15142 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15143
15144 // wrapper function for command vkDestroySamplerYcbcrConversionKHR, see
15145 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySamplerYcbcrConversionKHR.html
15146 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15147 void destroySamplerYcbcrConversionKHR( SamplerYcbcrConversion ycbcrConversion,
15148 const AllocationCallbacks * pAllocator,
15149 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15150 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15151 // wrapper function for command vkDestroySamplerYcbcrConversionKHR, see
15152 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySamplerYcbcrConversionKHR.html
15153 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15154 void destroySamplerYcbcrConversionKHR( SamplerYcbcrConversion ycbcrConversion VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
15155 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
15156 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15157 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15158
15159 //=== VK_KHR_bind_memory2 ===
15160
15161 // wrapper function for command vkBindBufferMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindBufferMemory2KHR.html
15162 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15163 VULKAN_HPP_NODISCARD Result bindBufferMemory2KHR( uint32_t bindInfoCount,
15164 const BindBufferMemoryInfo * pBindInfos,
15165 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15166 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15167 // wrapper function for command vkBindBufferMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindBufferMemory2KHR.html
15168 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15169 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
15170 bindBufferMemory2KHR( ArrayProxy<const BindBufferMemoryInfo> const & bindInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15171 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15172
15173 // wrapper function for command vkBindImageMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindImageMemory2KHR.html
15174 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15175 VULKAN_HPP_NODISCARD Result bindImageMemory2KHR( uint32_t bindInfoCount,
15176 const BindImageMemoryInfo * pBindInfos,
15177 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15178 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15179 // wrapper function for command vkBindImageMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindImageMemory2KHR.html
15180 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15181 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
15182 bindImageMemory2KHR( ArrayProxy<const BindImageMemoryInfo> const & bindInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15183 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15184
15185 //=== VK_EXT_image_drm_format_modifier ===
15186
15187 // wrapper function for command vkGetImageDrmFormatModifierPropertiesEXT, see
15188 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageDrmFormatModifierPropertiesEXT.html
15189 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15190 VULKAN_HPP_NODISCARD Result getImageDrmFormatModifierPropertiesEXT( Image image,
15191 ImageDrmFormatModifierPropertiesEXT * pProperties,
15192 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15193 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15194 // wrapper function for command vkGetImageDrmFormatModifierPropertiesEXT, see
15195 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageDrmFormatModifierPropertiesEXT.html
15196 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15197 VULKAN_HPP_NODISCARD typename ResultValueType<ImageDrmFormatModifierPropertiesEXT>::type
15198 getImageDrmFormatModifierPropertiesEXT( Image image, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15199 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15200
15201 //=== VK_EXT_validation_cache ===
15202
15203 // wrapper function for command vkCreateValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateValidationCacheEXT.html
15204 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15205 VULKAN_HPP_NODISCARD Result createValidationCacheEXT( const ValidationCacheCreateInfoEXT * pCreateInfo,
15206 const AllocationCallbacks * pAllocator,
15207 ValidationCacheEXT * pValidationCache,
15208 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15209 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15210 // wrapper function for command vkCreateValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateValidationCacheEXT.html
15211 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15212 VULKAN_HPP_NODISCARD typename ResultValueType<ValidationCacheEXT>::type
15213 createValidationCacheEXT( const ValidationCacheCreateInfoEXT & createInfo,
15214 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
15215 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15216 # ifndef VULKAN_HPP_NO_SMART_HANDLE
15217 // wrapper function for command vkCreateValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateValidationCacheEXT.html
15218 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15219 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<ValidationCacheEXT, Dispatch>>::type
15220 createValidationCacheEXTUnique( const ValidationCacheCreateInfoEXT & createInfo,
15221 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
15222 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15223 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
15224 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15225
15226 // wrapper function for command vkDestroyValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyValidationCacheEXT.html
15227 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15228 void destroyValidationCacheEXT( ValidationCacheEXT validationCache,
15229 const AllocationCallbacks * pAllocator,
15230 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15231 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15232 // wrapper function for command vkDestroyValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyValidationCacheEXT.html
15233 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15234 void destroyValidationCacheEXT( ValidationCacheEXT validationCache VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
15235 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
15236 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15237 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15238
15239 // wrapper function for command vkDestroyValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyValidationCacheEXT.html
15240 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15241 void destroy( ValidationCacheEXT validationCache,
15242 const AllocationCallbacks * pAllocator,
15243 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15244 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15245 // wrapper function for command vkDestroyValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyValidationCacheEXT.html
15246 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15247 void destroy( ValidationCacheEXT validationCache,
15248 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
15249 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15250 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15251
15252 // wrapper function for command vkMergeValidationCachesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMergeValidationCachesEXT.html
15253 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15254 VULKAN_HPP_NODISCARD Result mergeValidationCachesEXT( ValidationCacheEXT dstCache,
15255 uint32_t srcCacheCount,
15256 const ValidationCacheEXT * pSrcCaches,
15257 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15258 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15259 // wrapper function for command vkMergeValidationCachesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMergeValidationCachesEXT.html
15260 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15261 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type mergeValidationCachesEXT(
15262 ValidationCacheEXT dstCache, ArrayProxy<const ValidationCacheEXT> const & srcCaches, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15263 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15264
15265 // wrapper function for command vkGetValidationCacheDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetValidationCacheDataEXT.html
15266 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15267 VULKAN_HPP_NODISCARD Result getValidationCacheDataEXT( ValidationCacheEXT validationCache,
15268 size_t * pDataSize,
15269 void * pData,
15270 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15271 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15272 // wrapper function for command vkGetValidationCacheDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetValidationCacheDataEXT.html
15273 template <typename Uint8_tAllocator = std::allocator<uint8_t>,
15274 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15275 typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0,
15276 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15277 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
15278 getValidationCacheDataEXT( ValidationCacheEXT validationCache, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15279 // wrapper function for command vkGetValidationCacheDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetValidationCacheDataEXT.html
15280 template <typename Uint8_tAllocator = std::allocator<uint8_t>,
15281 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15282 typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0,
15283 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15284 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type getValidationCacheDataEXT(
15285 ValidationCacheEXT validationCache, Uint8_tAllocator & uint8_tAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15286 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15287
15288 //=== VK_NV_ray_tracing ===
15289
15290 // wrapper function for command vkCreateAccelerationStructureNV, see
15291 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAccelerationStructureNV.html
15292 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15293 VULKAN_HPP_NODISCARD Result createAccelerationStructureNV( const AccelerationStructureCreateInfoNV * pCreateInfo,
15294 const AllocationCallbacks * pAllocator,
15295 AccelerationStructureNV * pAccelerationStructure,
15296 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15297 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15298 // wrapper function for command vkCreateAccelerationStructureNV, see
15299 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAccelerationStructureNV.html
15300 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15301 VULKAN_HPP_NODISCARD typename ResultValueType<AccelerationStructureNV>::type
15302 createAccelerationStructureNV( const AccelerationStructureCreateInfoNV & createInfo,
15303 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
15304 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15305 # ifndef VULKAN_HPP_NO_SMART_HANDLE
15306 // wrapper function for command vkCreateAccelerationStructureNV, see
15307 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAccelerationStructureNV.html
15308 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15309 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<AccelerationStructureNV, Dispatch>>::type
15310 createAccelerationStructureNVUnique( const AccelerationStructureCreateInfoNV & createInfo,
15311 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
15312 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15313 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
15314 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15315
15316 // wrapper function for command vkDestroyAccelerationStructureNV, see
15317 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyAccelerationStructureNV.html
15318 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15319 void destroyAccelerationStructureNV( AccelerationStructureNV accelerationStructure,
15320 const AllocationCallbacks * pAllocator,
15321 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15322 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15323 // wrapper function for command vkDestroyAccelerationStructureNV, see
15324 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyAccelerationStructureNV.html
15325 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15326 void destroyAccelerationStructureNV( AccelerationStructureNV accelerationStructure VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
15327 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
15328 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15329 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15330
15331 // wrapper function for command vkDestroyAccelerationStructureNV, see
15332 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyAccelerationStructureNV.html
15333 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15334 void destroy( AccelerationStructureNV accelerationStructure,
15335 const AllocationCallbacks * pAllocator,
15336 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15337 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15338 // wrapper function for command vkDestroyAccelerationStructureNV, see
15339 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyAccelerationStructureNV.html
15340 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15341 void destroy( AccelerationStructureNV accelerationStructure,
15342 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
15343 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15344 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15345
15346 // wrapper function for command vkGetAccelerationStructureMemoryRequirementsNV, see
15347 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureMemoryRequirementsNV.html
15348 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15349 void getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV * pInfo,
15350 MemoryRequirements2KHR * pMemoryRequirements,
15351 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15352 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15353 // wrapper function for command vkGetAccelerationStructureMemoryRequirementsNV, see
15354 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureMemoryRequirementsNV.html
15355 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15356 VULKAN_HPP_NODISCARD MemoryRequirements2KHR getAccelerationStructureMemoryRequirementsNV(
15357 const AccelerationStructureMemoryRequirementsInfoNV & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15358 // wrapper function for command vkGetAccelerationStructureMemoryRequirementsNV, see
15359 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureMemoryRequirementsNV.html
15360 template <typename X,
15361 typename Y,
15362 typename... Z,
15363 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15364 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15365 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
15366 getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV & info,
15367 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15368 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15369
15370 // wrapper function for command vkBindAccelerationStructureMemoryNV, see
15371 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindAccelerationStructureMemoryNV.html
15372 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15373 VULKAN_HPP_NODISCARD Result bindAccelerationStructureMemoryNV( uint32_t bindInfoCount,
15374 const BindAccelerationStructureMemoryInfoNV * pBindInfos,
15375 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15376 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15377 // wrapper function for command vkBindAccelerationStructureMemoryNV, see
15378 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindAccelerationStructureMemoryNV.html
15379 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15380 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
15381 bindAccelerationStructureMemoryNV( ArrayProxy<const BindAccelerationStructureMemoryInfoNV> const & bindInfos,
15382 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15383 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15384
15385 // wrapper function for command vkCreateRayTracingPipelinesNV, see
15386 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesNV.html
15387 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15388 VULKAN_HPP_NODISCARD Result createRayTracingPipelinesNV( PipelineCache pipelineCache,
15389 uint32_t createInfoCount,
15390 const RayTracingPipelineCreateInfoNV * pCreateInfos,
15391 const AllocationCallbacks * pAllocator,
15392 Pipeline * pPipelines,
15393 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15394 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15395 // wrapper function for command vkCreateRayTracingPipelinesNV, see
15396 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesNV.html
15397 template <typename PipelineAllocator = std::allocator<Pipeline>,
15398 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15399 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, Pipeline>::value, int>::type = 0,
15400 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15401 VULKAN_HPP_NODISCARD ResultValue<std::vector<Pipeline, PipelineAllocator>>
15402 createRayTracingPipelinesNV( PipelineCache pipelineCache,
15403 ArrayProxy<const RayTracingPipelineCreateInfoNV> const & createInfos,
15404 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
15405 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15406 // wrapper function for command vkCreateRayTracingPipelinesNV, see
15407 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesNV.html
15408 template <typename PipelineAllocator = std::allocator<Pipeline>,
15409 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15410 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, Pipeline>::value, int>::type = 0,
15411 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15412 VULKAN_HPP_NODISCARD ResultValue<std::vector<Pipeline, PipelineAllocator>>
15413 createRayTracingPipelinesNV( PipelineCache pipelineCache,
15414 ArrayProxy<const RayTracingPipelineCreateInfoNV> const & createInfos,
15415 Optional<const AllocationCallbacks> allocator,
15416 PipelineAllocator & pipelineAllocator,
15417 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15418 // wrapper function for command vkCreateRayTracingPipelinesNV, see
15419 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesNV.html
15420 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15421 VULKAN_HPP_NODISCARD ResultValue<Pipeline>
15422 createRayTracingPipelineNV( PipelineCache pipelineCache,
15423 const RayTracingPipelineCreateInfoNV & createInfo,
15424 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
15425 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15426 # ifndef VULKAN_HPP_NO_SMART_HANDLE
15427 // wrapper function for command vkCreateRayTracingPipelinesNV, see
15428 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesNV.html
15429 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15430 typename PipelineAllocator = std::allocator<UniqueHandle<Pipeline, Dispatch>>,
15431 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<Pipeline, Dispatch>>::value, int>::type = 0,
15432 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15433 VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
15434 createRayTracingPipelinesNVUnique( PipelineCache pipelineCache,
15435 ArrayProxy<const RayTracingPipelineCreateInfoNV> const & createInfos,
15436 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
15437 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15438 // wrapper function for command vkCreateRayTracingPipelinesNV, see
15439 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesNV.html
15440 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15441 typename PipelineAllocator = std::allocator<UniqueHandle<Pipeline, Dispatch>>,
15442 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<Pipeline, Dispatch>>::value, int>::type = 0,
15443 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15444 VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
15445 createRayTracingPipelinesNVUnique( PipelineCache pipelineCache,
15446 ArrayProxy<const RayTracingPipelineCreateInfoNV> const & createInfos,
15447 Optional<const AllocationCallbacks> allocator,
15448 PipelineAllocator & pipelineAllocator,
15449 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15450 // wrapper function for command vkCreateRayTracingPipelinesNV, see
15451 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesNV.html
15452 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15453 VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<Pipeline, Dispatch>>
15454 createRayTracingPipelineNVUnique( PipelineCache pipelineCache,
15455 const RayTracingPipelineCreateInfoNV & createInfo,
15456 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
15457 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15458 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
15459 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15460
15461 // wrapper function for command vkGetRayTracingShaderGroupHandlesNV, see
15462 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupHandlesNV.html
15463 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15464 VULKAN_HPP_NODISCARD Result getRayTracingShaderGroupHandlesNV( Pipeline pipeline,
15465 uint32_t firstGroup,
15466 uint32_t groupCount,
15467 size_t dataSize,
15468 void * pData,
15469 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15470 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15471 // wrapper function for command vkGetRayTracingShaderGroupHandlesNV, see
15472 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupHandlesNV.html
15473 template <typename DataType,
15474 typename DataTypeAllocator = std::allocator<DataType>,
15475 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15476 typename std::enable_if<std::is_same<typename DataTypeAllocator::value_type, DataType>::value, int>::type = 0,
15477 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15478 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type getRayTracingShaderGroupHandlesNV(
15479 Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15480 // wrapper function for command vkGetRayTracingShaderGroupHandlesNV, see
15481 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupHandlesNV.html
15482 template <typename DataType,
15483 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15484 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15485 VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type getRayTracingShaderGroupHandleNV(
15486 Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15487 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15488
15489 // wrapper function for command vkGetAccelerationStructureHandleNV, see
15490 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureHandleNV.html
15491 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15492 VULKAN_HPP_NODISCARD Result getAccelerationStructureHandleNV( AccelerationStructureNV accelerationStructure,
15493 size_t dataSize,
15494 void * pData,
15495 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15496 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15497 // wrapper function for command vkGetAccelerationStructureHandleNV, see
15498 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureHandleNV.html
15499 template <typename DataType,
15500 typename DataTypeAllocator = std::allocator<DataType>,
15501 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15502 typename std::enable_if<std::is_same<typename DataTypeAllocator::value_type, DataType>::value, int>::type = 0,
15503 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15504 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type getAccelerationStructureHandleNV(
15505 AccelerationStructureNV accelerationStructure, size_t dataSize, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15506 // wrapper function for command vkGetAccelerationStructureHandleNV, see
15507 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureHandleNV.html
15508 template <typename DataType,
15509 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15510 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15511 VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type
15512 getAccelerationStructureHandleNV( AccelerationStructureNV accelerationStructure, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15513 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15514
15515 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
15516 // wrapper function for command vkCompileDeferredNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCompileDeferredNV.html
15517 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15518 VULKAN_HPP_NODISCARD Result compileDeferredNV( Pipeline pipeline,
15519 uint32_t shader,
15520 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15521 #else
15522 // wrapper function for command vkCompileDeferredNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCompileDeferredNV.html
15523 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15524 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
15525 compileDeferredNV( Pipeline pipeline, uint32_t shader, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15526 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
15527
15528 //=== VK_KHR_maintenance3 ===
15529
15530 // wrapper function for command vkGetDescriptorSetLayoutSupportKHR, see
15531 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSupportKHR.html
15532 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15533 void getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo * pCreateInfo,
15534 DescriptorSetLayoutSupport * pSupport,
15535 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15536 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15537 // wrapper function for command vkGetDescriptorSetLayoutSupportKHR, see
15538 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSupportKHR.html
15539 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15540 VULKAN_HPP_NODISCARD DescriptorSetLayoutSupport getDescriptorSetLayoutSupportKHR(
15541 const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15542 // wrapper function for command vkGetDescriptorSetLayoutSupportKHR, see
15543 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSupportKHR.html
15544 template <typename X,
15545 typename Y,
15546 typename... Z,
15547 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15548 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15549 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
15550 getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo,
15551 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15552 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15553
15554 //=== VK_EXT_external_memory_host ===
15555
15556 // wrapper function for command vkGetMemoryHostPointerPropertiesEXT, see
15557 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryHostPointerPropertiesEXT.html
15558 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15559 VULKAN_HPP_NODISCARD Result getMemoryHostPointerPropertiesEXT( ExternalMemoryHandleTypeFlagBits handleType,
15560 const void * pHostPointer,
15561 MemoryHostPointerPropertiesEXT * pMemoryHostPointerProperties,
15562 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15563 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15564 // wrapper function for command vkGetMemoryHostPointerPropertiesEXT, see
15565 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryHostPointerPropertiesEXT.html
15566 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15567 VULKAN_HPP_NODISCARD typename ResultValueType<MemoryHostPointerPropertiesEXT>::type getMemoryHostPointerPropertiesEXT(
15568 ExternalMemoryHandleTypeFlagBits handleType, const void * pHostPointer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15569 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15570
15571 //=== VK_EXT_calibrated_timestamps ===
15572
15573 // wrapper function for command vkGetCalibratedTimestampsEXT, see
15574 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsEXT.html
15575 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15576 VULKAN_HPP_NODISCARD Result getCalibratedTimestampsEXT( uint32_t timestampCount,
15577 const CalibratedTimestampInfoKHR * pTimestampInfos,
15578 uint64_t * pTimestamps,
15579 uint64_t * pMaxDeviation,
15580 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15581 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15582 // wrapper function for command vkGetCalibratedTimestampsEXT, see
15583 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsEXT.html
15584 template <typename Uint64_tAllocator = std::allocator<uint64_t>,
15585 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15586 typename std::enable_if<std::is_same<typename Uint64_tAllocator::value_type, uint64_t>::value, int>::type = 0,
15587 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15588 VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type
15589 getCalibratedTimestampsEXT( ArrayProxy<const CalibratedTimestampInfoKHR> const & timestampInfos,
15590 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15591 // wrapper function for command vkGetCalibratedTimestampsEXT, see
15592 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsEXT.html
15593 template <typename Uint64_tAllocator = std::allocator<uint64_t>,
15594 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15595 typename std::enable_if<std::is_same<typename Uint64_tAllocator::value_type, uint64_t>::value, int>::type = 0,
15596 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15597 VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type
15598 getCalibratedTimestampsEXT( ArrayProxy<const CalibratedTimestampInfoKHR> const & timestampInfos,
15599 Uint64_tAllocator & uint64_tAllocator,
15600 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15601 // wrapper function for command vkGetCalibratedTimestampsEXT, see
15602 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsEXT.html
15603 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15604 VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<uint64_t, uint64_t>>::type
15605 getCalibratedTimestampEXT( const CalibratedTimestampInfoKHR & timestampInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15606 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15607
15608 //=== VK_KHR_timeline_semaphore ===
15609
15610 // wrapper function for command vkGetSemaphoreCounterValueKHR, see
15611 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreCounterValueKHR.html
15612 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15613 VULKAN_HPP_NODISCARD Result getSemaphoreCounterValueKHR( Semaphore semaphore,
15614 uint64_t * pValue,
15615 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15616 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15617 // wrapper function for command vkGetSemaphoreCounterValueKHR, see
15618 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreCounterValueKHR.html
15619 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15620 VULKAN_HPP_NODISCARD typename ResultValueType<uint64_t>::type
15621 getSemaphoreCounterValueKHR( Semaphore semaphore, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15622 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15623
15624 // wrapper function for command vkWaitSemaphoresKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitSemaphoresKHR.html
15625 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15626 VULKAN_HPP_NODISCARD Result waitSemaphoresKHR( const SemaphoreWaitInfo * pWaitInfo,
15627 uint64_t timeout,
15628 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15629 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15630 // wrapper function for command vkWaitSemaphoresKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitSemaphoresKHR.html
15631 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15632 VULKAN_HPP_NODISCARD Result waitSemaphoresKHR( const SemaphoreWaitInfo & waitInfo,
15633 uint64_t timeout,
15634 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15635 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15636
15637 // wrapper function for command vkSignalSemaphoreKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSignalSemaphoreKHR.html
15638 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15639 VULKAN_HPP_NODISCARD Result signalSemaphoreKHR( const SemaphoreSignalInfo * pSignalInfo,
15640 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15641 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15642 // wrapper function for command vkSignalSemaphoreKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSignalSemaphoreKHR.html
15643 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15644 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
15645 signalSemaphoreKHR( const SemaphoreSignalInfo & signalInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15646 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15647
15648 //=== VK_INTEL_performance_query ===
15649
15650 // wrapper function for command vkInitializePerformanceApiINTEL, see
15651 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkInitializePerformanceApiINTEL.html
15652 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15653 VULKAN_HPP_NODISCARD Result initializePerformanceApiINTEL( const InitializePerformanceApiInfoINTEL * pInitializeInfo,
15654 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15655 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15656 // wrapper function for command vkInitializePerformanceApiINTEL, see
15657 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkInitializePerformanceApiINTEL.html
15658 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15659 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
15660 initializePerformanceApiINTEL( const InitializePerformanceApiInfoINTEL & initializeInfo,
15661 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15662 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15663
15664 // wrapper function for command vkUninitializePerformanceApiINTEL, see
15665 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUninitializePerformanceApiINTEL.html
15666 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15667 void uninitializePerformanceApiINTEL( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15668
15669 // wrapper function for command vkAcquirePerformanceConfigurationINTEL, see
15670 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquirePerformanceConfigurationINTEL.html
15671 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15672 VULKAN_HPP_NODISCARD Result acquirePerformanceConfigurationINTEL( const PerformanceConfigurationAcquireInfoINTEL * pAcquireInfo,
15673 PerformanceConfigurationINTEL * pConfiguration,
15674 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15675 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15676 // wrapper function for command vkAcquirePerformanceConfigurationINTEL, see
15677 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquirePerformanceConfigurationINTEL.html
15678 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15679 VULKAN_HPP_NODISCARD typename ResultValueType<PerformanceConfigurationINTEL>::type
15680 acquirePerformanceConfigurationINTEL( const PerformanceConfigurationAcquireInfoINTEL & acquireInfo,
15681 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15682 # ifndef VULKAN_HPP_NO_SMART_HANDLE
15683 // wrapper function for command vkAcquirePerformanceConfigurationINTEL, see
15684 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquirePerformanceConfigurationINTEL.html
15685 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15686 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<PerformanceConfigurationINTEL, Dispatch>>::type
15687 acquirePerformanceConfigurationINTELUnique( const PerformanceConfigurationAcquireInfoINTEL & acquireInfo,
15688 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15689 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
15690 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15691
15692 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
15693 // wrapper function for command vkReleasePerformanceConfigurationINTEL, see
15694 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleasePerformanceConfigurationINTEL.html
15695 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15696 VULKAN_HPP_NODISCARD Result releasePerformanceConfigurationINTEL( PerformanceConfigurationINTEL configuration,
15697 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15698 #else
15699 // wrapper function for command vkReleasePerformanceConfigurationINTEL, see
15700 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleasePerformanceConfigurationINTEL.html
15701 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15702 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
15703 releasePerformanceConfigurationINTEL( PerformanceConfigurationINTEL configuration VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
15704 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15705 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
15706
15707 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
15708 // wrapper function for command vkReleasePerformanceConfigurationINTEL, see
15709 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleasePerformanceConfigurationINTEL.html
15710 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15711 VULKAN_HPP_NODISCARD Result release( PerformanceConfigurationINTEL configuration,
15712 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15713 #else
15714 // wrapper function for command vkReleasePerformanceConfigurationINTEL, see
15715 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleasePerformanceConfigurationINTEL.html
15716 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15717 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type release( PerformanceConfigurationINTEL configuration,
15718 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15719 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
15720
15721 // wrapper function for command vkGetPerformanceParameterINTEL, see
15722 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPerformanceParameterINTEL.html
15723 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15724 VULKAN_HPP_NODISCARD Result getPerformanceParameterINTEL( PerformanceParameterTypeINTEL parameter,
15725 PerformanceValueINTEL * pValue,
15726 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15727 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15728 // wrapper function for command vkGetPerformanceParameterINTEL, see
15729 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPerformanceParameterINTEL.html
15730 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15731 VULKAN_HPP_NODISCARD typename ResultValueType<PerformanceValueINTEL>::type
15732 getPerformanceParameterINTEL( PerformanceParameterTypeINTEL parameter, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15733 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15734
15735 //=== VK_AMD_display_native_hdr ===
15736
15737 // wrapper function for command vkSetLocalDimmingAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetLocalDimmingAMD.html
15738 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15739 void setLocalDimmingAMD( SwapchainKHR swapChain,
15740 Bool32 localDimmingEnable,
15741 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15742
15743 //=== VK_EXT_buffer_device_address ===
15744
15745 // wrapper function for command vkGetBufferDeviceAddressEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferDeviceAddressEXT.html
15746 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15747 DeviceAddress getBufferAddressEXT( const BufferDeviceAddressInfo * pInfo,
15748 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15749 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15750 // wrapper function for command vkGetBufferDeviceAddressEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferDeviceAddressEXT.html
15751 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15752 DeviceAddress getBufferAddressEXT( const BufferDeviceAddressInfo & info,
15753 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15754 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15755
15756 //=== VK_KHR_present_wait ===
15757
15758 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
15759 // wrapper function for command vkWaitForPresentKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitForPresentKHR.html
15760 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15761 VULKAN_HPP_NODISCARD Result waitForPresentKHR( SwapchainKHR swapchain,
15762 uint64_t presentId,
15763 uint64_t timeout,
15764 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15765 #else
15766 // wrapper function for command vkWaitForPresentKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitForPresentKHR.html
15767 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15768 VULKAN_HPP_NODISCARD Result
15769 waitForPresentKHR( SwapchainKHR swapchain, uint64_t presentId, uint64_t timeout, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15770 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
15771
15772 #if defined( VK_USE_PLATFORM_WIN32_KHR )
15773 //=== VK_EXT_full_screen_exclusive ===
15774
15775 # ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
15776 // wrapper function for command vkAcquireFullScreenExclusiveModeEXT, see
15777 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireFullScreenExclusiveModeEXT.html
15778 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15779 VULKAN_HPP_NODISCARD Result acquireFullScreenExclusiveModeEXT( SwapchainKHR swapchain,
15780 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15781 # else
15782 // wrapper function for command vkAcquireFullScreenExclusiveModeEXT, see
15783 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireFullScreenExclusiveModeEXT.html
15784 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15785 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
15786 acquireFullScreenExclusiveModeEXT( SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15787 # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
15788
15789 # ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
15790 // wrapper function for command vkReleaseFullScreenExclusiveModeEXT, see
15791 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseFullScreenExclusiveModeEXT.html
15792 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15793 VULKAN_HPP_NODISCARD Result releaseFullScreenExclusiveModeEXT( SwapchainKHR swapchain,
15794 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15795 # else
15796 // wrapper function for command vkReleaseFullScreenExclusiveModeEXT, see
15797 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseFullScreenExclusiveModeEXT.html
15798 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15799 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
15800 releaseFullScreenExclusiveModeEXT( SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15801 # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
15802
15803 // wrapper function for command vkGetDeviceGroupSurfacePresentModes2EXT, see
15804 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupSurfacePresentModes2EXT.html
15805 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15806 VULKAN_HPP_NODISCARD Result getGroupSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
15807 DeviceGroupPresentModeFlagsKHR * pModes,
15808 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15809 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15810 // wrapper function for command vkGetDeviceGroupSurfacePresentModes2EXT, see
15811 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupSurfacePresentModes2EXT.html
15812 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15813 VULKAN_HPP_NODISCARD typename ResultValueType<DeviceGroupPresentModeFlagsKHR>::type
15814 getGroupSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15815 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15816 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
15817
15818 //=== VK_KHR_buffer_device_address ===
15819
15820 // wrapper function for command vkGetBufferDeviceAddressKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferDeviceAddressKHR.html
15821 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15822 DeviceAddress getBufferAddressKHR( const BufferDeviceAddressInfo * pInfo,
15823 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15824 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15825 // wrapper function for command vkGetBufferDeviceAddressKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferDeviceAddressKHR.html
15826 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15827 DeviceAddress getBufferAddressKHR( const BufferDeviceAddressInfo & info,
15828 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15829 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15830
15831 // wrapper function for command vkGetBufferOpaqueCaptureAddressKHR, see
15832 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferOpaqueCaptureAddressKHR.html
15833 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15834 uint64_t getBufferOpaqueCaptureAddressKHR( const BufferDeviceAddressInfo * pInfo,
15835 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15836 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15837 // wrapper function for command vkGetBufferOpaqueCaptureAddressKHR, see
15838 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferOpaqueCaptureAddressKHR.html
15839 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15840 uint64_t getBufferOpaqueCaptureAddressKHR( const BufferDeviceAddressInfo & info,
15841 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15842 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15843
15844 // wrapper function for command vkGetDeviceMemoryOpaqueCaptureAddressKHR, see
15845 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMemoryOpaqueCaptureAddressKHR.html
15846 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15847 uint64_t getMemoryOpaqueCaptureAddressKHR( const DeviceMemoryOpaqueCaptureAddressInfo * pInfo,
15848 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15849 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15850 // wrapper function for command vkGetDeviceMemoryOpaqueCaptureAddressKHR, see
15851 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMemoryOpaqueCaptureAddressKHR.html
15852 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15853 uint64_t getMemoryOpaqueCaptureAddressKHR( const DeviceMemoryOpaqueCaptureAddressInfo & info,
15854 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15855 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15856
15857 //=== VK_EXT_host_query_reset ===
15858
15859 // wrapper function for command vkResetQueryPoolEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetQueryPoolEXT.html
15860 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15861 void resetQueryPoolEXT( QueryPool queryPool,
15862 uint32_t firstQuery,
15863 uint32_t queryCount,
15864 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15865
15866 //=== VK_KHR_deferred_host_operations ===
15867
15868 // wrapper function for command vkCreateDeferredOperationKHR, see
15869 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDeferredOperationKHR.html
15870 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15871 VULKAN_HPP_NODISCARD Result createDeferredOperationKHR( const AllocationCallbacks * pAllocator,
15872 DeferredOperationKHR * pDeferredOperation,
15873 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15874 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15875 // wrapper function for command vkCreateDeferredOperationKHR, see
15876 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDeferredOperationKHR.html
15877 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15878 VULKAN_HPP_NODISCARD typename ResultValueType<DeferredOperationKHR>::type
15879 createDeferredOperationKHR( Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
15880 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15881 # ifndef VULKAN_HPP_NO_SMART_HANDLE
15882 // wrapper function for command vkCreateDeferredOperationKHR, see
15883 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDeferredOperationKHR.html
15884 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15885 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<DeferredOperationKHR, Dispatch>>::type
15886 createDeferredOperationKHRUnique( Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
15887 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15888 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
15889 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15890
15891 // wrapper function for command vkDestroyDeferredOperationKHR, see
15892 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDeferredOperationKHR.html
15893 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15894 void destroyDeferredOperationKHR( DeferredOperationKHR operation,
15895 const AllocationCallbacks * pAllocator,
15896 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15897 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15898 // wrapper function for command vkDestroyDeferredOperationKHR, see
15899 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDeferredOperationKHR.html
15900 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15901 void destroyDeferredOperationKHR( DeferredOperationKHR operation VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
15902 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
15903 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15904 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15905
15906 // wrapper function for command vkDestroyDeferredOperationKHR, see
15907 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDeferredOperationKHR.html
15908 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15909 void destroy( DeferredOperationKHR operation,
15910 const AllocationCallbacks * pAllocator,
15911 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15912 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15913 // wrapper function for command vkDestroyDeferredOperationKHR, see
15914 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDeferredOperationKHR.html
15915 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15916 void destroy( DeferredOperationKHR operation,
15917 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
15918 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15919 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15920
15921 // wrapper function for command vkGetDeferredOperationMaxConcurrencyKHR, see
15922 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeferredOperationMaxConcurrencyKHR.html
15923 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15924 uint32_t getDeferredOperationMaxConcurrencyKHR( DeferredOperationKHR operation,
15925 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15926
15927 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
15928 // wrapper function for command vkGetDeferredOperationResultKHR, see
15929 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeferredOperationResultKHR.html
15930 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15931 VULKAN_HPP_NODISCARD Result getDeferredOperationResultKHR( DeferredOperationKHR operation,
15932 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15933 #else
15934 // wrapper function for command vkGetDeferredOperationResultKHR, see
15935 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeferredOperationResultKHR.html
15936 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15937 VULKAN_HPP_NODISCARD Result getDeferredOperationResultKHR( DeferredOperationKHR operation,
15938 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15939 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
15940
15941 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
15942 // wrapper function for command vkDeferredOperationJoinKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDeferredOperationJoinKHR.html
15943 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15944 VULKAN_HPP_NODISCARD Result deferredOperationJoinKHR( DeferredOperationKHR operation,
15945 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15946 #else
15947 // wrapper function for command vkDeferredOperationJoinKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDeferredOperationJoinKHR.html
15948 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15949 VULKAN_HPP_NODISCARD Result deferredOperationJoinKHR( DeferredOperationKHR operation, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15950 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
15951
15952 //=== VK_KHR_pipeline_executable_properties ===
15953
15954 // wrapper function for command vkGetPipelineExecutablePropertiesKHR, see
15955 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutablePropertiesKHR.html
15956 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15957 VULKAN_HPP_NODISCARD Result getPipelineExecutablePropertiesKHR( const PipelineInfoKHR * pPipelineInfo,
15958 uint32_t * pExecutableCount,
15959 PipelineExecutablePropertiesKHR * pProperties,
15960 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15961 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15962 // wrapper function for command vkGetPipelineExecutablePropertiesKHR, see
15963 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutablePropertiesKHR.html
15964 template <typename PipelineExecutablePropertiesKHRAllocator = std::allocator<PipelineExecutablePropertiesKHR>,
15965 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15966 typename std::enable_if<std::is_same<typename PipelineExecutablePropertiesKHRAllocator::value_type, PipelineExecutablePropertiesKHR>::value,
15967 int>::type = 0,
15968 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15969 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PipelineExecutablePropertiesKHR, PipelineExecutablePropertiesKHRAllocator>>::type
15970 getPipelineExecutablePropertiesKHR( const PipelineInfoKHR & pipelineInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15971 // wrapper function for command vkGetPipelineExecutablePropertiesKHR, see
15972 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutablePropertiesKHR.html
15973 template <typename PipelineExecutablePropertiesKHRAllocator = std::allocator<PipelineExecutablePropertiesKHR>,
15974 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15975 typename std::enable_if<std::is_same<typename PipelineExecutablePropertiesKHRAllocator::value_type, PipelineExecutablePropertiesKHR>::value,
15976 int>::type = 0,
15977 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15978 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PipelineExecutablePropertiesKHR, PipelineExecutablePropertiesKHRAllocator>>::type
15979 getPipelineExecutablePropertiesKHR( const PipelineInfoKHR & pipelineInfo,
15980 PipelineExecutablePropertiesKHRAllocator & pipelineExecutablePropertiesKHRAllocator,
15981 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15982 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15983
15984 // wrapper function for command vkGetPipelineExecutableStatisticsKHR, see
15985 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutableStatisticsKHR.html
15986 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15987 VULKAN_HPP_NODISCARD Result getPipelineExecutableStatisticsKHR( const PipelineExecutableInfoKHR * pExecutableInfo,
15988 uint32_t * pStatisticCount,
15989 PipelineExecutableStatisticKHR * pStatistics,
15990 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15991 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15992 // wrapper function for command vkGetPipelineExecutableStatisticsKHR, see
15993 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutableStatisticsKHR.html
15994 template <
15995 typename PipelineExecutableStatisticKHRAllocator = std::allocator<PipelineExecutableStatisticKHR>,
15996 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15997 typename std::enable_if<std::is_same<typename PipelineExecutableStatisticKHRAllocator::value_type, PipelineExecutableStatisticKHR>::value, int>::type = 0,
15998 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
15999 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PipelineExecutableStatisticKHR, PipelineExecutableStatisticKHRAllocator>>::type
16000 getPipelineExecutableStatisticsKHR( const PipelineExecutableInfoKHR & executableInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16001 // wrapper function for command vkGetPipelineExecutableStatisticsKHR, see
16002 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutableStatisticsKHR.html
16003 template <
16004 typename PipelineExecutableStatisticKHRAllocator = std::allocator<PipelineExecutableStatisticKHR>,
16005 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
16006 typename std::enable_if<std::is_same<typename PipelineExecutableStatisticKHRAllocator::value_type, PipelineExecutableStatisticKHR>::value, int>::type = 0,
16007 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16008 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PipelineExecutableStatisticKHR, PipelineExecutableStatisticKHRAllocator>>::type
16009 getPipelineExecutableStatisticsKHR( const PipelineExecutableInfoKHR & executableInfo,
16010 PipelineExecutableStatisticKHRAllocator & pipelineExecutableStatisticKHRAllocator,
16011 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16012 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16013
16014 // wrapper function for command vkGetPipelineExecutableInternalRepresentationsKHR, see
16015 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutableInternalRepresentationsKHR.html
16016 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16017 VULKAN_HPP_NODISCARD Result
16018 getPipelineExecutableInternalRepresentationsKHR( const PipelineExecutableInfoKHR * pExecutableInfo,
16019 uint32_t * pInternalRepresentationCount,
16020 PipelineExecutableInternalRepresentationKHR * pInternalRepresentations,
16021 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16022 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16023 // wrapper function for command vkGetPipelineExecutableInternalRepresentationsKHR, see
16024 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutableInternalRepresentationsKHR.html
16025 template <typename PipelineExecutableInternalRepresentationKHRAllocator = std::allocator<PipelineExecutableInternalRepresentationKHR>,
16026 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
16027 typename std::enable_if<
16028 std::is_same<typename PipelineExecutableInternalRepresentationKHRAllocator::value_type, PipelineExecutableInternalRepresentationKHR>::value,
16029 int>::type = 0,
16030 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16031 VULKAN_HPP_NODISCARD
16032 typename ResultValueType<std::vector<PipelineExecutableInternalRepresentationKHR, PipelineExecutableInternalRepresentationKHRAllocator>>::type
16033 getPipelineExecutableInternalRepresentationsKHR( const PipelineExecutableInfoKHR & executableInfo,
16034 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16035 // wrapper function for command vkGetPipelineExecutableInternalRepresentationsKHR, see
16036 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutableInternalRepresentationsKHR.html
16037 template <typename PipelineExecutableInternalRepresentationKHRAllocator = std::allocator<PipelineExecutableInternalRepresentationKHR>,
16038 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
16039 typename std::enable_if<
16040 std::is_same<typename PipelineExecutableInternalRepresentationKHRAllocator::value_type, PipelineExecutableInternalRepresentationKHR>::value,
16041 int>::type = 0,
16042 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16043 VULKAN_HPP_NODISCARD
16044 typename ResultValueType<std::vector<PipelineExecutableInternalRepresentationKHR, PipelineExecutableInternalRepresentationKHRAllocator>>::type
16045 getPipelineExecutableInternalRepresentationsKHR(
16046 const PipelineExecutableInfoKHR & executableInfo,
16047 PipelineExecutableInternalRepresentationKHRAllocator & pipelineExecutableInternalRepresentationKHRAllocator,
16048 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16049 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16050
16051 //=== VK_EXT_host_image_copy ===
16052
16053 // wrapper function for command vkCopyMemoryToImageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToImageEXT.html
16054 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16055 VULKAN_HPP_NODISCARD Result copyMemoryToImageEXT( const CopyMemoryToImageInfo * pCopyMemoryToImageInfo,
16056 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16057 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16058 // wrapper function for command vkCopyMemoryToImageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToImageEXT.html
16059 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16060 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
16061 copyMemoryToImageEXT( const CopyMemoryToImageInfo & copyMemoryToImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16062 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16063
16064 // wrapper function for command vkCopyImageToMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToMemoryEXT.html
16065 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16066 VULKAN_HPP_NODISCARD Result copyImageToMemoryEXT( const CopyImageToMemoryInfo * pCopyImageToMemoryInfo,
16067 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16068 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16069 // wrapper function for command vkCopyImageToMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToMemoryEXT.html
16070 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16071 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
16072 copyImageToMemoryEXT( const CopyImageToMemoryInfo & copyImageToMemoryInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16073 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16074
16075 // wrapper function for command vkCopyImageToImageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToImageEXT.html
16076 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16077 VULKAN_HPP_NODISCARD Result copyImageToImageEXT( const CopyImageToImageInfo * pCopyImageToImageInfo,
16078 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16079 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16080 // wrapper function for command vkCopyImageToImageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToImageEXT.html
16081 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16082 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
16083 copyImageToImageEXT( const CopyImageToImageInfo & copyImageToImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16084 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16085
16086 // wrapper function for command vkTransitionImageLayoutEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkTransitionImageLayoutEXT.html
16087 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16088 VULKAN_HPP_NODISCARD Result transitionImageLayoutEXT( uint32_t transitionCount,
16089 const HostImageLayoutTransitionInfo * pTransitions,
16090 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16091 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16092 // wrapper function for command vkTransitionImageLayoutEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkTransitionImageLayoutEXT.html
16093 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16094 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
16095 transitionImageLayoutEXT( ArrayProxy<const HostImageLayoutTransitionInfo> const & transitions,
16096 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16097 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16098
16099 // wrapper function for command vkGetImageSubresourceLayout2EXT, see
16100 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2EXT.html
16101 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16102 void getImageSubresourceLayout2EXT( Image image,
16103 const ImageSubresource2 * pSubresource,
16104 SubresourceLayout2 * pLayout,
16105 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16106 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16107 // wrapper function for command vkGetImageSubresourceLayout2EXT, see
16108 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2EXT.html
16109 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16110 VULKAN_HPP_NODISCARD SubresourceLayout2 getImageSubresourceLayout2EXT(
16111 Image image, const ImageSubresource2 & subresource, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16112 // wrapper function for command vkGetImageSubresourceLayout2EXT, see
16113 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2EXT.html
16114 template <typename X,
16115 typename Y,
16116 typename... Z,
16117 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
16118 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16119 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getImageSubresourceLayout2EXT(
16120 Image image, const ImageSubresource2 & subresource, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16121 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16122
16123 //=== VK_KHR_map_memory2 ===
16124
16125 // wrapper function for command vkMapMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMapMemory2KHR.html
16126 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16127 VULKAN_HPP_NODISCARD Result mapMemory2KHR( const MemoryMapInfo * pMemoryMapInfo,
16128 void ** ppData,
16129 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16130 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16131 // wrapper function for command vkMapMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMapMemory2KHR.html
16132 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16133 VULKAN_HPP_NODISCARD typename ResultValueType<void *>::type mapMemory2KHR( const MemoryMapInfo & memoryMapInfo,
16134 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16135 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16136
16137 // wrapper function for command vkUnmapMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnmapMemory2KHR.html
16138 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16139 VULKAN_HPP_NODISCARD Result unmapMemory2KHR( const MemoryUnmapInfo * pMemoryUnmapInfo,
16140 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16141 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16142 // wrapper function for command vkUnmapMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnmapMemory2KHR.html
16143 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16144 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
16145 unmapMemory2KHR( const MemoryUnmapInfo & memoryUnmapInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16146 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16147
16148 //=== VK_EXT_swapchain_maintenance1 ===
16149
16150 // wrapper function for command vkReleaseSwapchainImagesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseSwapchainImagesEXT.html
16151 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16152 VULKAN_HPP_NODISCARD Result releaseSwapchainImagesEXT( const ReleaseSwapchainImagesInfoKHR * pReleaseInfo,
16153 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16154 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16155 // wrapper function for command vkReleaseSwapchainImagesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseSwapchainImagesEXT.html
16156 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16157 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
16158 releaseSwapchainImagesEXT( const ReleaseSwapchainImagesInfoKHR & releaseInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16159 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16160
16161 //=== VK_NV_device_generated_commands ===
16162
16163 // wrapper function for command vkGetGeneratedCommandsMemoryRequirementsNV, see
16164 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGeneratedCommandsMemoryRequirementsNV.html
16165 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16166 void getGeneratedCommandsMemoryRequirementsNV( const GeneratedCommandsMemoryRequirementsInfoNV * pInfo,
16167 MemoryRequirements2 * pMemoryRequirements,
16168 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16169 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16170 // wrapper function for command vkGetGeneratedCommandsMemoryRequirementsNV, see
16171 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGeneratedCommandsMemoryRequirementsNV.html
16172 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16173 VULKAN_HPP_NODISCARD MemoryRequirements2 getGeneratedCommandsMemoryRequirementsNV(
16174 const GeneratedCommandsMemoryRequirementsInfoNV & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16175 // wrapper function for command vkGetGeneratedCommandsMemoryRequirementsNV, see
16176 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGeneratedCommandsMemoryRequirementsNV.html
16177 template <typename X,
16178 typename Y,
16179 typename... Z,
16180 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
16181 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16182 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
16183 getGeneratedCommandsMemoryRequirementsNV( const GeneratedCommandsMemoryRequirementsInfoNV & info,
16184 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16185 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16186
16187 // wrapper function for command vkCreateIndirectCommandsLayoutNV, see
16188 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectCommandsLayoutNV.html
16189 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16190 VULKAN_HPP_NODISCARD Result createIndirectCommandsLayoutNV( const IndirectCommandsLayoutCreateInfoNV * pCreateInfo,
16191 const AllocationCallbacks * pAllocator,
16192 IndirectCommandsLayoutNV * pIndirectCommandsLayout,
16193 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16194 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16195 // wrapper function for command vkCreateIndirectCommandsLayoutNV, see
16196 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectCommandsLayoutNV.html
16197 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16198 VULKAN_HPP_NODISCARD typename ResultValueType<IndirectCommandsLayoutNV>::type
16199 createIndirectCommandsLayoutNV( const IndirectCommandsLayoutCreateInfoNV & createInfo,
16200 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
16201 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16202 # ifndef VULKAN_HPP_NO_SMART_HANDLE
16203 // wrapper function for command vkCreateIndirectCommandsLayoutNV, see
16204 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectCommandsLayoutNV.html
16205 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16206 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<IndirectCommandsLayoutNV, Dispatch>>::type
16207 createIndirectCommandsLayoutNVUnique( const IndirectCommandsLayoutCreateInfoNV & createInfo,
16208 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
16209 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16210 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
16211 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16212
16213 // wrapper function for command vkDestroyIndirectCommandsLayoutNV, see
16214 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectCommandsLayoutNV.html
16215 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16216 void destroyIndirectCommandsLayoutNV( IndirectCommandsLayoutNV indirectCommandsLayout,
16217 const AllocationCallbacks * pAllocator,
16218 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16219 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16220 // wrapper function for command vkDestroyIndirectCommandsLayoutNV, see
16221 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectCommandsLayoutNV.html
16222 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16223 void destroyIndirectCommandsLayoutNV( IndirectCommandsLayoutNV indirectCommandsLayout VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
16224 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
16225 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16226 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16227
16228 // wrapper function for command vkDestroyIndirectCommandsLayoutNV, see
16229 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectCommandsLayoutNV.html
16230 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16231 void destroy( IndirectCommandsLayoutNV indirectCommandsLayout,
16232 const AllocationCallbacks * pAllocator,
16233 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16234 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16235 // wrapper function for command vkDestroyIndirectCommandsLayoutNV, see
16236 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectCommandsLayoutNV.html
16237 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16238 void destroy( IndirectCommandsLayoutNV indirectCommandsLayout,
16239 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
16240 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16241 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16242
16243 //=== VK_EXT_private_data ===
16244
16245 // wrapper function for command vkCreatePrivateDataSlotEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePrivateDataSlotEXT.html
16246 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16247 VULKAN_HPP_NODISCARD Result createPrivateDataSlotEXT( const PrivateDataSlotCreateInfo * pCreateInfo,
16248 const AllocationCallbacks * pAllocator,
16249 PrivateDataSlot * pPrivateDataSlot,
16250 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16251 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16252 // wrapper function for command vkCreatePrivateDataSlotEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePrivateDataSlotEXT.html
16253 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16254 VULKAN_HPP_NODISCARD typename ResultValueType<PrivateDataSlot>::type
16255 createPrivateDataSlotEXT( const PrivateDataSlotCreateInfo & createInfo,
16256 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
16257 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16258 # ifndef VULKAN_HPP_NO_SMART_HANDLE
16259 // wrapper function for command vkCreatePrivateDataSlotEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePrivateDataSlotEXT.html
16260 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16261 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<PrivateDataSlot, Dispatch>>::type
16262 createPrivateDataSlotEXTUnique( const PrivateDataSlotCreateInfo & createInfo,
16263 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
16264 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16265 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
16266 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16267
16268 // wrapper function for command vkDestroyPrivateDataSlotEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPrivateDataSlotEXT.html
16269 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16270 void destroyPrivateDataSlotEXT( PrivateDataSlot privateDataSlot,
16271 const AllocationCallbacks * pAllocator,
16272 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16273 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16274 // wrapper function for command vkDestroyPrivateDataSlotEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPrivateDataSlotEXT.html
16275 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16276 void destroyPrivateDataSlotEXT( PrivateDataSlot privateDataSlot VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
16277 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
16278 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16279 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16280
16281 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
16282 // wrapper function for command vkSetPrivateDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetPrivateDataEXT.html
16283 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16284 VULKAN_HPP_NODISCARD Result setPrivateDataEXT( ObjectType objectType,
16285 uint64_t objectHandle,
16286 PrivateDataSlot privateDataSlot,
16287 uint64_t data,
16288 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16289 #else
16290 // wrapper function for command vkSetPrivateDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetPrivateDataEXT.html
16291 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16292 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
16293 setPrivateDataEXT( ObjectType objectType,
16294 uint64_t objectHandle,
16295 PrivateDataSlot privateDataSlot,
16296 uint64_t data,
16297 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16298 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
16299
16300 // wrapper function for command vkGetPrivateDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPrivateDataEXT.html
16301 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16302 void getPrivateDataEXT( ObjectType objectType,
16303 uint64_t objectHandle,
16304 PrivateDataSlot privateDataSlot,
16305 uint64_t * pData,
16306 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16307 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16308 // wrapper function for command vkGetPrivateDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPrivateDataEXT.html
16309 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16310 VULKAN_HPP_NODISCARD uint64_t getPrivateDataEXT( ObjectType objectType,
16311 uint64_t objectHandle,
16312 PrivateDataSlot privateDataSlot,
16313 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16314 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16315
16316 //=== VK_KHR_video_encode_queue ===
16317
16318 // wrapper function for command vkGetEncodedVideoSessionParametersKHR, see
16319 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEncodedVideoSessionParametersKHR.html
16320 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16321 VULKAN_HPP_NODISCARD Result getEncodedVideoSessionParametersKHR( const VideoEncodeSessionParametersGetInfoKHR * pVideoSessionParametersInfo,
16322 VideoEncodeSessionParametersFeedbackInfoKHR * pFeedbackInfo,
16323 size_t * pDataSize,
16324 void * pData,
16325 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16326 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16327 // wrapper function for command vkGetEncodedVideoSessionParametersKHR, see
16328 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEncodedVideoSessionParametersKHR.html
16329 template <typename Uint8_tAllocator = std::allocator<uint8_t>,
16330 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
16331 typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0,
16332 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16333 VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<VideoEncodeSessionParametersFeedbackInfoKHR, std::vector<uint8_t, Uint8_tAllocator>>>::type
16334 getEncodedVideoSessionParametersKHR( const VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo,
16335 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16336 // wrapper function for command vkGetEncodedVideoSessionParametersKHR, see
16337 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEncodedVideoSessionParametersKHR.html
16338 template <typename Uint8_tAllocator = std::allocator<uint8_t>,
16339 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
16340 typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0,
16341 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16342 VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<VideoEncodeSessionParametersFeedbackInfoKHR, std::vector<uint8_t, Uint8_tAllocator>>>::type
16343 getEncodedVideoSessionParametersKHR( const VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo,
16344 Uint8_tAllocator & uint8_tAllocator,
16345 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16346 // wrapper function for command vkGetEncodedVideoSessionParametersKHR, see
16347 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEncodedVideoSessionParametersKHR.html
16348 template <typename X,
16349 typename Y,
16350 typename... Z,
16351 typename Uint8_tAllocator = std::allocator<uint8_t>,
16352 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
16353 typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0,
16354 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16355 VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<StructureChain<X, Y, Z...>, std::vector<uint8_t, Uint8_tAllocator>>>::type
16356 getEncodedVideoSessionParametersKHR( const VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo,
16357 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16358 // wrapper function for command vkGetEncodedVideoSessionParametersKHR, see
16359 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEncodedVideoSessionParametersKHR.html
16360 template <typename X,
16361 typename Y,
16362 typename... Z,
16363 typename Uint8_tAllocator = std::allocator<uint8_t>,
16364 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
16365 typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0,
16366 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16367 VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<StructureChain<X, Y, Z...>, std::vector<uint8_t, Uint8_tAllocator>>>::type
16368 getEncodedVideoSessionParametersKHR( const VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo,
16369 Uint8_tAllocator & uint8_tAllocator,
16370 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16371 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16372
16373 #if defined( VK_ENABLE_BETA_EXTENSIONS )
16374 //=== VK_NV_cuda_kernel_launch ===
16375
16376 // wrapper function for command vkCreateCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCudaModuleNV.html
16377 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16378 VULKAN_HPP_NODISCARD Result createCudaModuleNV( const CudaModuleCreateInfoNV * pCreateInfo,
16379 const AllocationCallbacks * pAllocator,
16380 CudaModuleNV * pModule,
16381 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16382 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16383 // wrapper function for command vkCreateCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCudaModuleNV.html
16384 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16385 VULKAN_HPP_NODISCARD typename ResultValueType<CudaModuleNV>::type
16386 createCudaModuleNV( const CudaModuleCreateInfoNV & createInfo,
16387 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
16388 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16389 # ifndef VULKAN_HPP_NO_SMART_HANDLE
16390 // wrapper function for command vkCreateCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCudaModuleNV.html
16391 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16392 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<CudaModuleNV, Dispatch>>::type
16393 createCudaModuleNVUnique( const CudaModuleCreateInfoNV & createInfo,
16394 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
16395 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16396 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
16397 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16398
16399 // wrapper function for command vkGetCudaModuleCacheNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCudaModuleCacheNV.html
16400 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16401 VULKAN_HPP_NODISCARD Result getCudaModuleCacheNV( CudaModuleNV module,
16402 size_t * pCacheSize,
16403 void * pCacheData,
16404 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16405 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16406 // wrapper function for command vkGetCudaModuleCacheNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCudaModuleCacheNV.html
16407 template <typename Uint8_tAllocator = std::allocator<uint8_t>,
16408 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
16409 typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0,
16410 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16411 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
16412 getCudaModuleCacheNV( CudaModuleNV module, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16413 // wrapper function for command vkGetCudaModuleCacheNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCudaModuleCacheNV.html
16414 template <typename Uint8_tAllocator = std::allocator<uint8_t>,
16415 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
16416 typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0,
16417 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16418 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
16419 getCudaModuleCacheNV( CudaModuleNV module, Uint8_tAllocator & uint8_tAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16420 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16421
16422 // wrapper function for command vkCreateCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCudaFunctionNV.html
16423 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16424 VULKAN_HPP_NODISCARD Result createCudaFunctionNV( const CudaFunctionCreateInfoNV * pCreateInfo,
16425 const AllocationCallbacks * pAllocator,
16426 CudaFunctionNV * pFunction,
16427 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16428 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16429 // wrapper function for command vkCreateCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCudaFunctionNV.html
16430 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16431 VULKAN_HPP_NODISCARD typename ResultValueType<CudaFunctionNV>::type
16432 createCudaFunctionNV( const CudaFunctionCreateInfoNV & createInfo,
16433 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
16434 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16435 # ifndef VULKAN_HPP_NO_SMART_HANDLE
16436 // wrapper function for command vkCreateCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCudaFunctionNV.html
16437 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16438 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<CudaFunctionNV, Dispatch>>::type
16439 createCudaFunctionNVUnique( const CudaFunctionCreateInfoNV & createInfo,
16440 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
16441 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16442 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
16443 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16444
16445 // wrapper function for command vkDestroyCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCudaModuleNV.html
16446 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16447 void destroyCudaModuleNV( CudaModuleNV module,
16448 const AllocationCallbacks * pAllocator,
16449 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16450 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16451 // wrapper function for command vkDestroyCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCudaModuleNV.html
16452 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16453 void destroyCudaModuleNV( CudaModuleNV module,
16454 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
16455 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16456 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16457
16458 // wrapper function for command vkDestroyCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCudaModuleNV.html
16459 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16460 void destroy( CudaModuleNV module,
16461 const AllocationCallbacks * pAllocator,
16462 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16463 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16464 // wrapper function for command vkDestroyCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCudaModuleNV.html
16465 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16466 void destroy( CudaModuleNV module,
16467 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
16468 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16469 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16470
16471 // wrapper function for command vkDestroyCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCudaFunctionNV.html
16472 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16473 void destroyCudaFunctionNV( CudaFunctionNV function,
16474 const AllocationCallbacks * pAllocator,
16475 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16476 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16477 // wrapper function for command vkDestroyCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCudaFunctionNV.html
16478 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16479 void destroyCudaFunctionNV( CudaFunctionNV function,
16480 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
16481 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16482 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16483
16484 // wrapper function for command vkDestroyCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCudaFunctionNV.html
16485 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16486 void destroy( CudaFunctionNV function,
16487 const AllocationCallbacks * pAllocator,
16488 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16489 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16490 // wrapper function for command vkDestroyCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCudaFunctionNV.html
16491 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16492 void destroy( CudaFunctionNV function,
16493 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
16494 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16495 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16496 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
16497
16498 #if defined( VK_USE_PLATFORM_METAL_EXT )
16499 //=== VK_EXT_metal_objects ===
16500
16501 // wrapper function for command vkExportMetalObjectsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkExportMetalObjectsEXT.html
16502 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16503 void exportMetalObjectsEXT( ExportMetalObjectsInfoEXT * pMetalObjectsInfo,
16504 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16505 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16506 // wrapper function for command vkExportMetalObjectsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkExportMetalObjectsEXT.html
16507 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16508 void exportMetalObjectsEXT( ExportMetalObjectsInfoEXT & metalObjectsInfo,
16509 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16510 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16511 #endif /*VK_USE_PLATFORM_METAL_EXT*/
16512
16513 //=== VK_EXT_descriptor_buffer ===
16514
16515 // wrapper function for command vkGetDescriptorSetLayoutSizeEXT, see
16516 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSizeEXT.html
16517 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16518 void getDescriptorSetLayoutSizeEXT( DescriptorSetLayout layout,
16519 DeviceSize * pLayoutSizeInBytes,
16520 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16521 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16522 // wrapper function for command vkGetDescriptorSetLayoutSizeEXT, see
16523 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSizeEXT.html
16524 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16525 VULKAN_HPP_NODISCARD DeviceSize getDescriptorSetLayoutSizeEXT( DescriptorSetLayout layout,
16526 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16527 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16528
16529 // wrapper function for command vkGetDescriptorSetLayoutBindingOffsetEXT, see
16530 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutBindingOffsetEXT.html
16531 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16532 void getDescriptorSetLayoutBindingOffsetEXT( DescriptorSetLayout layout,
16533 uint32_t binding,
16534 DeviceSize * pOffset,
16535 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16536 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16537 // wrapper function for command vkGetDescriptorSetLayoutBindingOffsetEXT, see
16538 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutBindingOffsetEXT.html
16539 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16540 VULKAN_HPP_NODISCARD DeviceSize getDescriptorSetLayoutBindingOffsetEXT(
16541 DescriptorSetLayout layout, uint32_t binding, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16542 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16543
16544 // wrapper function for command vkGetDescriptorEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorEXT.html
16545 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16546 void getDescriptorEXT( const DescriptorGetInfoEXT * pDescriptorInfo,
16547 size_t dataSize,
16548 void * pDescriptor,
16549 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16550 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16551 // wrapper function for command vkGetDescriptorEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorEXT.html
16552 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16553 void getDescriptorEXT( const DescriptorGetInfoEXT & descriptorInfo,
16554 size_t dataSize,
16555 void * pDescriptor,
16556 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16557 // wrapper function for command vkGetDescriptorEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorEXT.html
16558 template <typename DescriptorType,
16559 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
16560 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16561 VULKAN_HPP_NODISCARD DescriptorType getDescriptorEXT( const DescriptorGetInfoEXT & descriptorInfo,
16562 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16563 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16564
16565 // wrapper function for command vkGetBufferOpaqueCaptureDescriptorDataEXT, see
16566 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferOpaqueCaptureDescriptorDataEXT.html
16567 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16568 VULKAN_HPP_NODISCARD Result getBufferOpaqueCaptureDescriptorDataEXT(
16569 const BufferCaptureDescriptorDataInfoEXT * pInfo, void * pData, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16570 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16571 // wrapper function for command vkGetBufferOpaqueCaptureDescriptorDataEXT, see
16572 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferOpaqueCaptureDescriptorDataEXT.html
16573 template <typename DataType,
16574 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
16575 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16576 VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type
16577 getBufferOpaqueCaptureDescriptorDataEXT( const BufferCaptureDescriptorDataInfoEXT & info,
16578 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16579 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16580
16581 // wrapper function for command vkGetImageOpaqueCaptureDescriptorDataEXT, see
16582 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageOpaqueCaptureDescriptorDataEXT.html
16583 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16584 VULKAN_HPP_NODISCARD Result getImageOpaqueCaptureDescriptorDataEXT( const ImageCaptureDescriptorDataInfoEXT * pInfo,
16585 void * pData,
16586 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16587 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16588 // wrapper function for command vkGetImageOpaqueCaptureDescriptorDataEXT, see
16589 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageOpaqueCaptureDescriptorDataEXT.html
16590 template <typename DataType,
16591 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
16592 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16593 VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type
16594 getImageOpaqueCaptureDescriptorDataEXT( const ImageCaptureDescriptorDataInfoEXT & info,
16595 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16596 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16597
16598 // wrapper function for command vkGetImageViewOpaqueCaptureDescriptorDataEXT, see
16599 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewOpaqueCaptureDescriptorDataEXT.html
16600 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16601 VULKAN_HPP_NODISCARD Result
16602 getImageViewOpaqueCaptureDescriptorDataEXT( const ImageViewCaptureDescriptorDataInfoEXT * pInfo,
16603 void * pData,
16604 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16605 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16606 // wrapper function for command vkGetImageViewOpaqueCaptureDescriptorDataEXT, see
16607 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewOpaqueCaptureDescriptorDataEXT.html
16608 template <typename DataType,
16609 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
16610 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16611 VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type
16612 getImageViewOpaqueCaptureDescriptorDataEXT( const ImageViewCaptureDescriptorDataInfoEXT & info,
16613 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16614 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16615
16616 // wrapper function for command vkGetSamplerOpaqueCaptureDescriptorDataEXT, see
16617 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSamplerOpaqueCaptureDescriptorDataEXT.html
16618 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16619 VULKAN_HPP_NODISCARD Result getSamplerOpaqueCaptureDescriptorDataEXT(
16620 const SamplerCaptureDescriptorDataInfoEXT * pInfo, void * pData, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16621 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16622 // wrapper function for command vkGetSamplerOpaqueCaptureDescriptorDataEXT, see
16623 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSamplerOpaqueCaptureDescriptorDataEXT.html
16624 template <typename DataType,
16625 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
16626 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16627 VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type
16628 getSamplerOpaqueCaptureDescriptorDataEXT( const SamplerCaptureDescriptorDataInfoEXT & info,
16629 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16630 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16631
16632 // wrapper function for command vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT, see
16633 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT.html
16634 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16635 VULKAN_HPP_NODISCARD Result
16636 getAccelerationStructureOpaqueCaptureDescriptorDataEXT( const AccelerationStructureCaptureDescriptorDataInfoEXT * pInfo,
16637 void * pData,
16638 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16639 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16640 // wrapper function for command vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT, see
16641 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT.html
16642 template <typename DataType,
16643 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
16644 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16645 VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type
16646 getAccelerationStructureOpaqueCaptureDescriptorDataEXT( const AccelerationStructureCaptureDescriptorDataInfoEXT & info,
16647 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16648 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16649
16650 //=== VK_EXT_device_fault ===
16651
16652 // wrapper function for command vkGetDeviceFaultInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceFaultInfoEXT.html
16653 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16654 VULKAN_HPP_NODISCARD Result getFaultInfoEXT( DeviceFaultCountsEXT * pFaultCounts,
16655 DeviceFaultInfoEXT * pFaultInfo,
16656 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16657
16658 #if defined( VK_USE_PLATFORM_FUCHSIA )
16659 //=== VK_FUCHSIA_external_memory ===
16660
16661 // wrapper function for command vkGetMemoryZirconHandleFUCHSIA, see
16662 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryZirconHandleFUCHSIA.html
16663 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16664 VULKAN_HPP_NODISCARD Result getMemoryZirconHandleFUCHSIA( const MemoryGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo,
16665 zx_handle_t * pZirconHandle,
16666 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16667 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16668 // wrapper function for command vkGetMemoryZirconHandleFUCHSIA, see
16669 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryZirconHandleFUCHSIA.html
16670 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16671 VULKAN_HPP_NODISCARD typename ResultValueType<zx_handle_t>::type
16672 getMemoryZirconHandleFUCHSIA( const MemoryGetZirconHandleInfoFUCHSIA & getZirconHandleInfo,
16673 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16674 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16675
16676 // wrapper function for command vkGetMemoryZirconHandlePropertiesFUCHSIA, see
16677 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryZirconHandlePropertiesFUCHSIA.html
16678 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16679 VULKAN_HPP_NODISCARD Result getMemoryZirconHandlePropertiesFUCHSIA( ExternalMemoryHandleTypeFlagBits handleType,
16680 zx_handle_t zirconHandle,
16681 MemoryZirconHandlePropertiesFUCHSIA * pMemoryZirconHandleProperties,
16682 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16683 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16684 // wrapper function for command vkGetMemoryZirconHandlePropertiesFUCHSIA, see
16685 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryZirconHandlePropertiesFUCHSIA.html
16686 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16687 VULKAN_HPP_NODISCARD typename ResultValueType<MemoryZirconHandlePropertiesFUCHSIA>::type getMemoryZirconHandlePropertiesFUCHSIA(
16688 ExternalMemoryHandleTypeFlagBits handleType, zx_handle_t zirconHandle, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16689 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16690 #endif /*VK_USE_PLATFORM_FUCHSIA*/
16691
16692 #if defined( VK_USE_PLATFORM_FUCHSIA )
16693 //=== VK_FUCHSIA_external_semaphore ===
16694
16695 // wrapper function for command vkImportSemaphoreZirconHandleFUCHSIA, see
16696 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportSemaphoreZirconHandleFUCHSIA.html
16697 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16698 VULKAN_HPP_NODISCARD Result importSemaphoreZirconHandleFUCHSIA( const ImportSemaphoreZirconHandleInfoFUCHSIA * pImportSemaphoreZirconHandleInfo,
16699 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16700 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16701 // wrapper function for command vkImportSemaphoreZirconHandleFUCHSIA, see
16702 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportSemaphoreZirconHandleFUCHSIA.html
16703 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16704 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
16705 importSemaphoreZirconHandleFUCHSIA( const ImportSemaphoreZirconHandleInfoFUCHSIA & importSemaphoreZirconHandleInfo,
16706 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16707 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16708
16709 // wrapper function for command vkGetSemaphoreZirconHandleFUCHSIA, see
16710 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreZirconHandleFUCHSIA.html
16711 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16712 VULKAN_HPP_NODISCARD Result getSemaphoreZirconHandleFUCHSIA( const SemaphoreGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo,
16713 zx_handle_t * pZirconHandle,
16714 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16715 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16716 // wrapper function for command vkGetSemaphoreZirconHandleFUCHSIA, see
16717 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreZirconHandleFUCHSIA.html
16718 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16719 VULKAN_HPP_NODISCARD typename ResultValueType<zx_handle_t>::type
16720 getSemaphoreZirconHandleFUCHSIA( const SemaphoreGetZirconHandleInfoFUCHSIA & getZirconHandleInfo,
16721 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16722 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16723 #endif /*VK_USE_PLATFORM_FUCHSIA*/
16724
16725 #if defined( VK_USE_PLATFORM_FUCHSIA )
16726 //=== VK_FUCHSIA_buffer_collection ===
16727
16728 // wrapper function for command vkCreateBufferCollectionFUCHSIA, see
16729 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBufferCollectionFUCHSIA.html
16730 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16731 VULKAN_HPP_NODISCARD Result createBufferCollectionFUCHSIA( const BufferCollectionCreateInfoFUCHSIA * pCreateInfo,
16732 const AllocationCallbacks * pAllocator,
16733 BufferCollectionFUCHSIA * pCollection,
16734 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16735 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16736 // wrapper function for command vkCreateBufferCollectionFUCHSIA, see
16737 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBufferCollectionFUCHSIA.html
16738 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16739 VULKAN_HPP_NODISCARD typename ResultValueType<BufferCollectionFUCHSIA>::type
16740 createBufferCollectionFUCHSIA( const BufferCollectionCreateInfoFUCHSIA & createInfo,
16741 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
16742 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16743 # ifndef VULKAN_HPP_NO_SMART_HANDLE
16744 // wrapper function for command vkCreateBufferCollectionFUCHSIA, see
16745 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBufferCollectionFUCHSIA.html
16746 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16747 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<BufferCollectionFUCHSIA, Dispatch>>::type
16748 createBufferCollectionFUCHSIAUnique( const BufferCollectionCreateInfoFUCHSIA & createInfo,
16749 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
16750 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16751 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
16752 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16753
16754 // wrapper function for command vkSetBufferCollectionImageConstraintsFUCHSIA, see
16755 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetBufferCollectionImageConstraintsFUCHSIA.html
16756 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16757 VULKAN_HPP_NODISCARD Result
16758 setBufferCollectionImageConstraintsFUCHSIA( BufferCollectionFUCHSIA collection,
16759 const ImageConstraintsInfoFUCHSIA * pImageConstraintsInfo,
16760 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16761 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16762 // wrapper function for command vkSetBufferCollectionImageConstraintsFUCHSIA, see
16763 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetBufferCollectionImageConstraintsFUCHSIA.html
16764 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16765 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
16766 setBufferCollectionImageConstraintsFUCHSIA( BufferCollectionFUCHSIA collection,
16767 const ImageConstraintsInfoFUCHSIA & imageConstraintsInfo,
16768 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16769 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16770
16771 // wrapper function for command vkSetBufferCollectionBufferConstraintsFUCHSIA, see
16772 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetBufferCollectionBufferConstraintsFUCHSIA.html
16773 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16774 VULKAN_HPP_NODISCARD Result
16775 setBufferCollectionBufferConstraintsFUCHSIA( BufferCollectionFUCHSIA collection,
16776 const BufferConstraintsInfoFUCHSIA * pBufferConstraintsInfo,
16777 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16778 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16779 // wrapper function for command vkSetBufferCollectionBufferConstraintsFUCHSIA, see
16780 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetBufferCollectionBufferConstraintsFUCHSIA.html
16781 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16782 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
16783 setBufferCollectionBufferConstraintsFUCHSIA( BufferCollectionFUCHSIA collection,
16784 const BufferConstraintsInfoFUCHSIA & bufferConstraintsInfo,
16785 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16786 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16787
16788 // wrapper function for command vkDestroyBufferCollectionFUCHSIA, see
16789 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBufferCollectionFUCHSIA.html
16790 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16791 void destroyBufferCollectionFUCHSIA( BufferCollectionFUCHSIA collection,
16792 const AllocationCallbacks * pAllocator,
16793 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16794 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16795 // wrapper function for command vkDestroyBufferCollectionFUCHSIA, see
16796 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBufferCollectionFUCHSIA.html
16797 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16798 void destroyBufferCollectionFUCHSIA( BufferCollectionFUCHSIA collection,
16799 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
16800 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16801 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16802
16803 // wrapper function for command vkDestroyBufferCollectionFUCHSIA, see
16804 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBufferCollectionFUCHSIA.html
16805 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16806 void destroy( BufferCollectionFUCHSIA collection,
16807 const AllocationCallbacks * pAllocator,
16808 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16809 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16810 // wrapper function for command vkDestroyBufferCollectionFUCHSIA, see
16811 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBufferCollectionFUCHSIA.html
16812 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16813 void destroy( BufferCollectionFUCHSIA collection,
16814 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
16815 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16816 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16817
16818 // wrapper function for command vkGetBufferCollectionPropertiesFUCHSIA, see
16819 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferCollectionPropertiesFUCHSIA.html
16820 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16821 VULKAN_HPP_NODISCARD Result getBufferCollectionPropertiesFUCHSIA( BufferCollectionFUCHSIA collection,
16822 BufferCollectionPropertiesFUCHSIA * pProperties,
16823 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16824 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16825 // wrapper function for command vkGetBufferCollectionPropertiesFUCHSIA, see
16826 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferCollectionPropertiesFUCHSIA.html
16827 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16828 VULKAN_HPP_NODISCARD typename ResultValueType<BufferCollectionPropertiesFUCHSIA>::type
16829 getBufferCollectionPropertiesFUCHSIA( BufferCollectionFUCHSIA collection, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16830 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16831 #endif /*VK_USE_PLATFORM_FUCHSIA*/
16832
16833 //=== VK_HUAWEI_subpass_shading ===
16834
16835 // wrapper function for command vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI, see
16836 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI.html
16837 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16838 VULKAN_HPP_NODISCARD Result getSubpassShadingMaxWorkgroupSizeHUAWEI(
16839 RenderPass renderpass, Extent2D * pMaxWorkgroupSize, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16840 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16841 // wrapper function for command vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI, see
16842 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI.html
16843 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16844 VULKAN_HPP_NODISCARD typename ResultValueType<Extent2D>::type
16845 getSubpassShadingMaxWorkgroupSizeHUAWEI( RenderPass renderpass, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16846 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16847
16848 //=== VK_NV_external_memory_rdma ===
16849
16850 // wrapper function for command vkGetMemoryRemoteAddressNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryRemoteAddressNV.html
16851 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16852 VULKAN_HPP_NODISCARD Result getMemoryRemoteAddressNV( const MemoryGetRemoteAddressInfoNV * pMemoryGetRemoteAddressInfo,
16853 RemoteAddressNV * pAddress,
16854 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16855 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16856 // wrapper function for command vkGetMemoryRemoteAddressNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryRemoteAddressNV.html
16857 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16858 VULKAN_HPP_NODISCARD typename ResultValueType<RemoteAddressNV>::type
16859 getMemoryRemoteAddressNV( const MemoryGetRemoteAddressInfoNV & memoryGetRemoteAddressInfo,
16860 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16861 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16862
16863 //=== VK_EXT_pipeline_properties ===
16864
16865 // wrapper function for command vkGetPipelinePropertiesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelinePropertiesEXT.html
16866 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16867 VULKAN_HPP_NODISCARD Result getPipelinePropertiesEXT( const PipelineInfoEXT * pPipelineInfo,
16868 BaseOutStructure * pPipelineProperties,
16869 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16870 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16871 // wrapper function for command vkGetPipelinePropertiesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelinePropertiesEXT.html
16872 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16873 VULKAN_HPP_NODISCARD typename ResultValueType<BaseOutStructure>::type
16874 getPipelinePropertiesEXT( const PipelineInfoEXT & pipelineInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16875 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16876
16877 //=== VK_EXT_opacity_micromap ===
16878
16879 // wrapper function for command vkCreateMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMicromapEXT.html
16880 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16881 VULKAN_HPP_NODISCARD Result createMicromapEXT( const MicromapCreateInfoEXT * pCreateInfo,
16882 const AllocationCallbacks * pAllocator,
16883 MicromapEXT * pMicromap,
16884 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16885 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16886 // wrapper function for command vkCreateMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMicromapEXT.html
16887 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16888 VULKAN_HPP_NODISCARD typename ResultValueType<MicromapEXT>::type
16889 createMicromapEXT( const MicromapCreateInfoEXT & createInfo,
16890 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
16891 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16892 # ifndef VULKAN_HPP_NO_SMART_HANDLE
16893 // wrapper function for command vkCreateMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMicromapEXT.html
16894 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16895 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<MicromapEXT, Dispatch>>::type
16896 createMicromapEXTUnique( const MicromapCreateInfoEXT & createInfo,
16897 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
16898 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16899 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
16900 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16901
16902 // wrapper function for command vkDestroyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyMicromapEXT.html
16903 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16904 void destroyMicromapEXT( MicromapEXT micromap,
16905 const AllocationCallbacks * pAllocator,
16906 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16907 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16908 // wrapper function for command vkDestroyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyMicromapEXT.html
16909 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16910 void destroyMicromapEXT( MicromapEXT micromap VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
16911 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
16912 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16913 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16914
16915 // wrapper function for command vkDestroyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyMicromapEXT.html
16916 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16917 void destroy( MicromapEXT micromap,
16918 const AllocationCallbacks * pAllocator,
16919 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16920 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16921 // wrapper function for command vkDestroyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyMicromapEXT.html
16922 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16923 void destroy( MicromapEXT micromap,
16924 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
16925 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16926 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16927
16928 // wrapper function for command vkBuildMicromapsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBuildMicromapsEXT.html
16929 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16930 VULKAN_HPP_NODISCARD Result buildMicromapsEXT( DeferredOperationKHR deferredOperation,
16931 uint32_t infoCount,
16932 const MicromapBuildInfoEXT * pInfos,
16933 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16934 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16935 // wrapper function for command vkBuildMicromapsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBuildMicromapsEXT.html
16936 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16937 VULKAN_HPP_NODISCARD Result buildMicromapsEXT( DeferredOperationKHR deferredOperation,
16938 ArrayProxy<const MicromapBuildInfoEXT> const & infos,
16939 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16940 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16941
16942 // wrapper function for command vkCopyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMicromapEXT.html
16943 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16944 VULKAN_HPP_NODISCARD Result copyMicromapEXT( DeferredOperationKHR deferredOperation,
16945 const CopyMicromapInfoEXT * pInfo,
16946 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16947 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16948 // wrapper function for command vkCopyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMicromapEXT.html
16949 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16950 VULKAN_HPP_NODISCARD Result copyMicromapEXT( DeferredOperationKHR deferredOperation,
16951 const CopyMicromapInfoEXT & info,
16952 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16953 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16954
16955 // wrapper function for command vkCopyMicromapToMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMicromapToMemoryEXT.html
16956 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16957 VULKAN_HPP_NODISCARD Result copyMicromapToMemoryEXT( DeferredOperationKHR deferredOperation,
16958 const CopyMicromapToMemoryInfoEXT * pInfo,
16959 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16960 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16961 // wrapper function for command vkCopyMicromapToMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMicromapToMemoryEXT.html
16962 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16963 VULKAN_HPP_NODISCARD Result copyMicromapToMemoryEXT( DeferredOperationKHR deferredOperation,
16964 const CopyMicromapToMemoryInfoEXT & info,
16965 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16966 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16967
16968 // wrapper function for command vkCopyMemoryToMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToMicromapEXT.html
16969 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16970 VULKAN_HPP_NODISCARD Result copyMemoryToMicromapEXT( DeferredOperationKHR deferredOperation,
16971 const CopyMemoryToMicromapInfoEXT * pInfo,
16972 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16973 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16974 // wrapper function for command vkCopyMemoryToMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToMicromapEXT.html
16975 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16976 VULKAN_HPP_NODISCARD Result copyMemoryToMicromapEXT( DeferredOperationKHR deferredOperation,
16977 const CopyMemoryToMicromapInfoEXT & info,
16978 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16979 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16980
16981 // wrapper function for command vkWriteMicromapsPropertiesEXT, see
16982 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteMicromapsPropertiesEXT.html
16983 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16984 VULKAN_HPP_NODISCARD Result writeMicromapsPropertiesEXT( uint32_t micromapCount,
16985 const MicromapEXT * pMicromaps,
16986 QueryType queryType,
16987 size_t dataSize,
16988 void * pData,
16989 size_t stride,
16990 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16991 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16992 // wrapper function for command vkWriteMicromapsPropertiesEXT, see
16993 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteMicromapsPropertiesEXT.html
16994 template <typename DataType,
16995 typename DataTypeAllocator = std::allocator<DataType>,
16996 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
16997 typename std::enable_if<std::is_same<typename DataTypeAllocator::value_type, DataType>::value, int>::type = 0,
16998 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
16999 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type
17000 writeMicromapsPropertiesEXT( ArrayProxy<const MicromapEXT> const & micromaps,
17001 QueryType queryType,
17002 size_t dataSize,
17003 size_t stride,
17004 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17005 // wrapper function for command vkWriteMicromapsPropertiesEXT, see
17006 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteMicromapsPropertiesEXT.html
17007 template <typename DataType,
17008 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
17009 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17010 VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type writeMicromapsPropertyEXT(
17011 ArrayProxy<const MicromapEXT> const & micromaps, QueryType queryType, size_t stride, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17012 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17013
17014 // wrapper function for command vkGetDeviceMicromapCompatibilityEXT, see
17015 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMicromapCompatibilityEXT.html
17016 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17017 void getMicromapCompatibilityEXT( const MicromapVersionInfoEXT * pVersionInfo,
17018 AccelerationStructureCompatibilityKHR * pCompatibility,
17019 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17020 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17021 // wrapper function for command vkGetDeviceMicromapCompatibilityEXT, see
17022 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMicromapCompatibilityEXT.html
17023 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17024 VULKAN_HPP_NODISCARD AccelerationStructureCompatibilityKHR getMicromapCompatibilityEXT(
17025 const MicromapVersionInfoEXT & versionInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17026 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17027
17028 // wrapper function for command vkGetMicromapBuildSizesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMicromapBuildSizesEXT.html
17029 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17030 void getMicromapBuildSizesEXT( AccelerationStructureBuildTypeKHR buildType,
17031 const MicromapBuildInfoEXT * pBuildInfo,
17032 MicromapBuildSizesInfoEXT * pSizeInfo,
17033 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17034 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17035 // wrapper function for command vkGetMicromapBuildSizesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMicromapBuildSizesEXT.html
17036 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17037 VULKAN_HPP_NODISCARD MicromapBuildSizesInfoEXT
17038 getMicromapBuildSizesEXT( AccelerationStructureBuildTypeKHR buildType,
17039 const MicromapBuildInfoEXT & buildInfo,
17040 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17041 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17042
17043 //=== VK_EXT_pageable_device_local_memory ===
17044
17045 // wrapper function for command vkSetDeviceMemoryPriorityEXT, see
17046 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDeviceMemoryPriorityEXT.html
17047 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17048 void setMemoryPriorityEXT( DeviceMemory memory, float priority, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17049
17050 //=== VK_KHR_maintenance4 ===
17051
17052 // wrapper function for command vkGetDeviceBufferMemoryRequirementsKHR, see
17053 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceBufferMemoryRequirementsKHR.html
17054 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17055 void getBufferMemoryRequirementsKHR( const DeviceBufferMemoryRequirements * pInfo,
17056 MemoryRequirements2 * pMemoryRequirements,
17057 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17058 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17059 // wrapper function for command vkGetDeviceBufferMemoryRequirementsKHR, see
17060 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceBufferMemoryRequirementsKHR.html
17061 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17062 VULKAN_HPP_NODISCARD MemoryRequirements2 getBufferMemoryRequirementsKHR(
17063 const DeviceBufferMemoryRequirements & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17064 // wrapper function for command vkGetDeviceBufferMemoryRequirementsKHR, see
17065 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceBufferMemoryRequirementsKHR.html
17066 template <typename X,
17067 typename Y,
17068 typename... Z,
17069 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
17070 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17071 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
17072 getBufferMemoryRequirementsKHR( const DeviceBufferMemoryRequirements & info,
17073 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17074 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17075
17076 // wrapper function for command vkGetDeviceImageMemoryRequirementsKHR, see
17077 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageMemoryRequirementsKHR.html
17078 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17079 void getImageMemoryRequirementsKHR( const DeviceImageMemoryRequirements * pInfo,
17080 MemoryRequirements2 * pMemoryRequirements,
17081 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17082 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17083 // wrapper function for command vkGetDeviceImageMemoryRequirementsKHR, see
17084 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageMemoryRequirementsKHR.html
17085 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17086 VULKAN_HPP_NODISCARD MemoryRequirements2 getImageMemoryRequirementsKHR(
17087 const DeviceImageMemoryRequirements & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17088 // wrapper function for command vkGetDeviceImageMemoryRequirementsKHR, see
17089 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageMemoryRequirementsKHR.html
17090 template <typename X,
17091 typename Y,
17092 typename... Z,
17093 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
17094 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17095 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
17096 getImageMemoryRequirementsKHR( const DeviceImageMemoryRequirements & info,
17097 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17098 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17099
17100 // wrapper function for command vkGetDeviceImageSparseMemoryRequirementsKHR, see
17101 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSparseMemoryRequirementsKHR.html
17102 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17103 void getImageSparseMemoryRequirementsKHR( const DeviceImageMemoryRequirements * pInfo,
17104 uint32_t * pSparseMemoryRequirementCount,
17105 SparseImageMemoryRequirements2 * pSparseMemoryRequirements,
17106 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17107 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17108 // wrapper function for command vkGetDeviceImageSparseMemoryRequirementsKHR, see
17109 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSparseMemoryRequirementsKHR.html
17110 template <
17111 typename SparseImageMemoryRequirements2Allocator = std::allocator<SparseImageMemoryRequirements2>,
17112 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
17113 typename std::enable_if<std::is_same<typename SparseImageMemoryRequirements2Allocator::value_type, SparseImageMemoryRequirements2>::value, int>::type = 0,
17114 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17115 VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
17116 getImageSparseMemoryRequirementsKHR( const DeviceImageMemoryRequirements & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17117 // wrapper function for command vkGetDeviceImageSparseMemoryRequirementsKHR, see
17118 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSparseMemoryRequirementsKHR.html
17119 template <
17120 typename SparseImageMemoryRequirements2Allocator = std::allocator<SparseImageMemoryRequirements2>,
17121 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
17122 typename std::enable_if<std::is_same<typename SparseImageMemoryRequirements2Allocator::value_type, SparseImageMemoryRequirements2>::value, int>::type = 0,
17123 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17124 VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
17125 getImageSparseMemoryRequirementsKHR( const DeviceImageMemoryRequirements & info,
17126 SparseImageMemoryRequirements2Allocator & sparseImageMemoryRequirements2Allocator,
17127 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17128 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17129
17130 //=== VK_VALVE_descriptor_set_host_mapping ===
17131
17132 // wrapper function for command vkGetDescriptorSetLayoutHostMappingInfoVALVE, see
17133 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutHostMappingInfoVALVE.html
17134 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17135 void getDescriptorSetLayoutHostMappingInfoVALVE( const DescriptorSetBindingReferenceVALVE * pBindingReference,
17136 DescriptorSetLayoutHostMappingInfoVALVE * pHostMapping,
17137 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17138 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17139 // wrapper function for command vkGetDescriptorSetLayoutHostMappingInfoVALVE, see
17140 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutHostMappingInfoVALVE.html
17141 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17142 VULKAN_HPP_NODISCARD DescriptorSetLayoutHostMappingInfoVALVE getDescriptorSetLayoutHostMappingInfoVALVE(
17143 const DescriptorSetBindingReferenceVALVE & bindingReference, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17144 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17145
17146 // wrapper function for command vkGetDescriptorSetHostMappingVALVE, see
17147 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetHostMappingVALVE.html
17148 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17149 void getDescriptorSetHostMappingVALVE( DescriptorSet descriptorSet,
17150 void ** ppData,
17151 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17152 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17153 // wrapper function for command vkGetDescriptorSetHostMappingVALVE, see
17154 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetHostMappingVALVE.html
17155 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17156 VULKAN_HPP_NODISCARD void * getDescriptorSetHostMappingVALVE( DescriptorSet descriptorSet,
17157 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17158 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17159
17160 //=== VK_NV_device_generated_commands_compute ===
17161
17162 // wrapper function for command vkGetPipelineIndirectMemoryRequirementsNV, see
17163 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineIndirectMemoryRequirementsNV.html
17164 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17165 void getPipelineIndirectMemoryRequirementsNV( const ComputePipelineCreateInfo * pCreateInfo,
17166 MemoryRequirements2 * pMemoryRequirements,
17167 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17168 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17169 // wrapper function for command vkGetPipelineIndirectMemoryRequirementsNV, see
17170 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineIndirectMemoryRequirementsNV.html
17171 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17172 VULKAN_HPP_NODISCARD MemoryRequirements2 getPipelineIndirectMemoryRequirementsNV(
17173 const ComputePipelineCreateInfo & createInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17174 // wrapper function for command vkGetPipelineIndirectMemoryRequirementsNV, see
17175 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineIndirectMemoryRequirementsNV.html
17176 template <typename X,
17177 typename Y,
17178 typename... Z,
17179 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
17180 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17181 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
17182 getPipelineIndirectMemoryRequirementsNV( const ComputePipelineCreateInfo & createInfo,
17183 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17184 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17185
17186 // wrapper function for command vkGetPipelineIndirectDeviceAddressNV, see
17187 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineIndirectDeviceAddressNV.html
17188 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17189 DeviceAddress getPipelineIndirectAddressNV( const PipelineIndirectDeviceAddressInfoNV * pInfo,
17190 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17191 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17192 // wrapper function for command vkGetPipelineIndirectDeviceAddressNV, see
17193 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineIndirectDeviceAddressNV.html
17194 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17195 DeviceAddress getPipelineIndirectAddressNV( const PipelineIndirectDeviceAddressInfoNV & info,
17196 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17197 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17198
17199 #if defined( VK_USE_PLATFORM_OHOS )
17200 //=== VK_OHOS_external_memory ===
17201
17202 // wrapper function for command vkGetNativeBufferPropertiesOHOS, see
17203 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetNativeBufferPropertiesOHOS.html
17204 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17205 VULKAN_HPP_NODISCARD Result getNativeBufferPropertiesOHOS( const struct OH_NativeBuffer * buffer,
17206 NativeBufferPropertiesOHOS * pProperties,
17207 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17208 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17209 // wrapper function for command vkGetNativeBufferPropertiesOHOS, see
17210 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetNativeBufferPropertiesOHOS.html
17211 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17212 VULKAN_HPP_NODISCARD typename ResultValueType<NativeBufferPropertiesOHOS>::type
17213 getNativeBufferPropertiesOHOS( const struct OH_NativeBuffer & buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17214 // wrapper function for command vkGetNativeBufferPropertiesOHOS, see
17215 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetNativeBufferPropertiesOHOS.html
17216 template <typename X,
17217 typename Y,
17218 typename... Z,
17219 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
17220 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17221 VULKAN_HPP_NODISCARD typename ResultValueType<StructureChain<X, Y, Z...>>::type
17222 getNativeBufferPropertiesOHOS( const struct OH_NativeBuffer & buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17223 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17224
17225 // wrapper function for command vkGetMemoryNativeBufferOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryNativeBufferOHOS.html
17226 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17227 VULKAN_HPP_NODISCARD Result getMemoryNativeBufferOHOS( const MemoryGetNativeBufferInfoOHOS * pInfo,
17228 struct OH_NativeBuffer ** pBuffer,
17229 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17230 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17231 // wrapper function for command vkGetMemoryNativeBufferOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryNativeBufferOHOS.html
17232 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17233 VULKAN_HPP_NODISCARD typename ResultValueType<struct OH_NativeBuffer *>::type
17234 getMemoryNativeBufferOHOS( const MemoryGetNativeBufferInfoOHOS & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17235 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17236 #endif /*VK_USE_PLATFORM_OHOS*/
17237
17238 //=== VK_ARM_tensors ===
17239
17240 // wrapper function for command vkCreateTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateTensorARM.html
17241 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17242 VULKAN_HPP_NODISCARD Result createTensorARM( const TensorCreateInfoARM * pCreateInfo,
17243 const AllocationCallbacks * pAllocator,
17244 TensorARM * pTensor,
17245 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17246 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17247 // wrapper function for command vkCreateTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateTensorARM.html
17248 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17249 VULKAN_HPP_NODISCARD typename ResultValueType<TensorARM>::type
17250 createTensorARM( const TensorCreateInfoARM & createInfo,
17251 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
17252 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17253 # ifndef VULKAN_HPP_NO_SMART_HANDLE
17254 // wrapper function for command vkCreateTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateTensorARM.html
17255 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17256 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<TensorARM, Dispatch>>::type
17257 createTensorARMUnique( const TensorCreateInfoARM & createInfo,
17258 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
17259 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17260 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
17261 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17262
17263 // wrapper function for command vkDestroyTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyTensorARM.html
17264 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17265 void destroyTensorARM( TensorARM tensor,
17266 const AllocationCallbacks * pAllocator,
17267 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17268 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17269 // wrapper function for command vkDestroyTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyTensorARM.html
17270 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17271 void destroyTensorARM( TensorARM tensor VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
17272 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
17273 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17274 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17275
17276 // wrapper function for command vkDestroyTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyTensorARM.html
17277 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17278 void destroy( TensorARM tensor,
17279 const AllocationCallbacks * pAllocator,
17280 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17281 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17282 // wrapper function for command vkDestroyTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyTensorARM.html
17283 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17284 void destroy( TensorARM tensor,
17285 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
17286 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17287 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17288
17289 // wrapper function for command vkCreateTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateTensorViewARM.html
17290 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17291 VULKAN_HPP_NODISCARD Result createTensorViewARM( const TensorViewCreateInfoARM * pCreateInfo,
17292 const AllocationCallbacks * pAllocator,
17293 TensorViewARM * pView,
17294 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17295 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17296 // wrapper function for command vkCreateTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateTensorViewARM.html
17297 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17298 VULKAN_HPP_NODISCARD typename ResultValueType<TensorViewARM>::type
17299 createTensorViewARM( const TensorViewCreateInfoARM & createInfo,
17300 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
17301 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17302 # ifndef VULKAN_HPP_NO_SMART_HANDLE
17303 // wrapper function for command vkCreateTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateTensorViewARM.html
17304 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17305 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<TensorViewARM, Dispatch>>::type
17306 createTensorViewARMUnique( const TensorViewCreateInfoARM & createInfo,
17307 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
17308 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17309 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
17310 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17311
17312 // wrapper function for command vkDestroyTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyTensorViewARM.html
17313 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17314 void destroyTensorViewARM( TensorViewARM tensorView,
17315 const AllocationCallbacks * pAllocator,
17316 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17317 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17318 // wrapper function for command vkDestroyTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyTensorViewARM.html
17319 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17320 void destroyTensorViewARM( TensorViewARM tensorView VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
17321 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
17322 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17323 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17324
17325 // wrapper function for command vkDestroyTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyTensorViewARM.html
17326 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17327 void destroy( TensorViewARM tensorView,
17328 const AllocationCallbacks * pAllocator,
17329 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17330 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17331 // wrapper function for command vkDestroyTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyTensorViewARM.html
17332 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17333 void destroy( TensorViewARM tensorView,
17334 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
17335 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17336 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17337
17338 // wrapper function for command vkGetTensorMemoryRequirementsARM, see
17339 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorMemoryRequirementsARM.html
17340 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17341 void getTensorMemoryRequirementsARM( const TensorMemoryRequirementsInfoARM * pInfo,
17342 MemoryRequirements2 * pMemoryRequirements,
17343 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17344 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17345 // wrapper function for command vkGetTensorMemoryRequirementsARM, see
17346 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorMemoryRequirementsARM.html
17347 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17348 VULKAN_HPP_NODISCARD MemoryRequirements2 getTensorMemoryRequirementsARM(
17349 const TensorMemoryRequirementsInfoARM & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17350 // wrapper function for command vkGetTensorMemoryRequirementsARM, see
17351 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorMemoryRequirementsARM.html
17352 template <typename X,
17353 typename Y,
17354 typename... Z,
17355 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
17356 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17357 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
17358 getTensorMemoryRequirementsARM( const TensorMemoryRequirementsInfoARM & info,
17359 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17360 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17361
17362 // wrapper function for command vkBindTensorMemoryARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindTensorMemoryARM.html
17363 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17364 VULKAN_HPP_NODISCARD Result bindTensorMemoryARM( uint32_t bindInfoCount,
17365 const BindTensorMemoryInfoARM * pBindInfos,
17366 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17367 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17368 // wrapper function for command vkBindTensorMemoryARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindTensorMemoryARM.html
17369 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17370 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
17371 bindTensorMemoryARM( ArrayProxy<const BindTensorMemoryInfoARM> const & bindInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17372 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17373
17374 // wrapper function for command vkGetDeviceTensorMemoryRequirementsARM, see
17375 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceTensorMemoryRequirementsARM.html
17376 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17377 void getTensorMemoryRequirementsARM( const DeviceTensorMemoryRequirementsARM * pInfo,
17378 MemoryRequirements2 * pMemoryRequirements,
17379 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17380 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17381 // wrapper function for command vkGetDeviceTensorMemoryRequirementsARM, see
17382 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceTensorMemoryRequirementsARM.html
17383 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17384 VULKAN_HPP_NODISCARD MemoryRequirements2 getTensorMemoryRequirementsARM(
17385 const DeviceTensorMemoryRequirementsARM & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17386 // wrapper function for command vkGetDeviceTensorMemoryRequirementsARM, see
17387 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceTensorMemoryRequirementsARM.html
17388 template <typename X,
17389 typename Y,
17390 typename... Z,
17391 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
17392 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17393 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
17394 getTensorMemoryRequirementsARM( const DeviceTensorMemoryRequirementsARM & info,
17395 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17396 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17397
17398 // wrapper function for command vkGetTensorOpaqueCaptureDescriptorDataARM, see
17399 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorOpaqueCaptureDescriptorDataARM.html
17400 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17401 VULKAN_HPP_NODISCARD Result getTensorOpaqueCaptureDescriptorDataARM(
17402 const TensorCaptureDescriptorDataInfoARM * pInfo, void * pData, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17403 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17404 // wrapper function for command vkGetTensorOpaqueCaptureDescriptorDataARM, see
17405 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorOpaqueCaptureDescriptorDataARM.html
17406 template <typename DataType,
17407 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
17408 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17409 VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type
17410 getTensorOpaqueCaptureDescriptorDataARM( const TensorCaptureDescriptorDataInfoARM & info,
17411 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17412 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17413
17414 // wrapper function for command vkGetTensorViewOpaqueCaptureDescriptorDataARM, see
17415 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorViewOpaqueCaptureDescriptorDataARM.html
17416 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17417 VULKAN_HPP_NODISCARD Result
17418 getTensorViewOpaqueCaptureDescriptorDataARM( const TensorViewCaptureDescriptorDataInfoARM * pInfo,
17419 void * pData,
17420 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17421 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17422 // wrapper function for command vkGetTensorViewOpaqueCaptureDescriptorDataARM, see
17423 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorViewOpaqueCaptureDescriptorDataARM.html
17424 template <typename DataType,
17425 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
17426 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17427 VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type
17428 getTensorViewOpaqueCaptureDescriptorDataARM( const TensorViewCaptureDescriptorDataInfoARM & info,
17429 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17430 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17431
17432 //=== VK_EXT_shader_module_identifier ===
17433
17434 // wrapper function for command vkGetShaderModuleIdentifierEXT, see
17435 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderModuleIdentifierEXT.html
17436 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17437 void getShaderModuleIdentifierEXT( ShaderModule shaderModule,
17438 ShaderModuleIdentifierEXT * pIdentifier,
17439 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17440 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17441 // wrapper function for command vkGetShaderModuleIdentifierEXT, see
17442 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderModuleIdentifierEXT.html
17443 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17444 VULKAN_HPP_NODISCARD ShaderModuleIdentifierEXT
17445 getShaderModuleIdentifierEXT( ShaderModule shaderModule, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17446 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17447
17448 // wrapper function for command vkGetShaderModuleCreateInfoIdentifierEXT, see
17449 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderModuleCreateInfoIdentifierEXT.html
17450 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17451 void getShaderModuleCreateInfoIdentifierEXT( const ShaderModuleCreateInfo * pCreateInfo,
17452 ShaderModuleIdentifierEXT * pIdentifier,
17453 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17454 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17455 // wrapper function for command vkGetShaderModuleCreateInfoIdentifierEXT, see
17456 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderModuleCreateInfoIdentifierEXT.html
17457 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17458 VULKAN_HPP_NODISCARD ShaderModuleIdentifierEXT getShaderModuleCreateInfoIdentifierEXT(
17459 const ShaderModuleCreateInfo & createInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17460 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17461
17462 //=== VK_NV_optical_flow ===
17463
17464 // wrapper function for command vkCreateOpticalFlowSessionNV, see
17465 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateOpticalFlowSessionNV.html
17466 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17467 VULKAN_HPP_NODISCARD Result createOpticalFlowSessionNV( const OpticalFlowSessionCreateInfoNV * pCreateInfo,
17468 const AllocationCallbacks * pAllocator,
17469 OpticalFlowSessionNV * pSession,
17470 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17471 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17472 // wrapper function for command vkCreateOpticalFlowSessionNV, see
17473 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateOpticalFlowSessionNV.html
17474 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17475 VULKAN_HPP_NODISCARD typename ResultValueType<OpticalFlowSessionNV>::type
17476 createOpticalFlowSessionNV( const OpticalFlowSessionCreateInfoNV & createInfo,
17477 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
17478 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17479 # ifndef VULKAN_HPP_NO_SMART_HANDLE
17480 // wrapper function for command vkCreateOpticalFlowSessionNV, see
17481 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateOpticalFlowSessionNV.html
17482 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17483 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<OpticalFlowSessionNV, Dispatch>>::type
17484 createOpticalFlowSessionNVUnique( const OpticalFlowSessionCreateInfoNV & createInfo,
17485 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
17486 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17487 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
17488 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17489
17490 // wrapper function for command vkDestroyOpticalFlowSessionNV, see
17491 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyOpticalFlowSessionNV.html
17492 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17493 void destroyOpticalFlowSessionNV( OpticalFlowSessionNV session,
17494 const AllocationCallbacks * pAllocator,
17495 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17496 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17497 // wrapper function for command vkDestroyOpticalFlowSessionNV, see
17498 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyOpticalFlowSessionNV.html
17499 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17500 void destroyOpticalFlowSessionNV( OpticalFlowSessionNV session,
17501 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
17502 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17503 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17504
17505 // wrapper function for command vkDestroyOpticalFlowSessionNV, see
17506 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyOpticalFlowSessionNV.html
17507 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17508 void destroy( OpticalFlowSessionNV session,
17509 const AllocationCallbacks * pAllocator,
17510 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17511 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17512 // wrapper function for command vkDestroyOpticalFlowSessionNV, see
17513 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyOpticalFlowSessionNV.html
17514 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17515 void destroy( OpticalFlowSessionNV session,
17516 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
17517 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17518 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17519
17520 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
17521 // wrapper function for command vkBindOpticalFlowSessionImageNV, see
17522 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindOpticalFlowSessionImageNV.html
17523 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17524 VULKAN_HPP_NODISCARD Result bindOpticalFlowSessionImageNV( OpticalFlowSessionNV session,
17525 OpticalFlowSessionBindingPointNV bindingPoint,
17526 ImageView view,
17527 ImageLayout layout,
17528 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17529 #else
17530 // wrapper function for command vkBindOpticalFlowSessionImageNV, see
17531 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindOpticalFlowSessionImageNV.html
17532 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17533 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
17534 bindOpticalFlowSessionImageNV( OpticalFlowSessionNV session,
17535 OpticalFlowSessionBindingPointNV bindingPoint,
17536 ImageView view,
17537 ImageLayout layout,
17538 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17539 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
17540
17541 //=== VK_KHR_maintenance5 ===
17542
17543 // wrapper function for command vkGetRenderingAreaGranularityKHR, see
17544 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRenderingAreaGranularityKHR.html
17545 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17546 void getRenderingAreaGranularityKHR( const RenderingAreaInfo * pRenderingAreaInfo,
17547 Extent2D * pGranularity,
17548 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17549 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17550 // wrapper function for command vkGetRenderingAreaGranularityKHR, see
17551 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRenderingAreaGranularityKHR.html
17552 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17553 VULKAN_HPP_NODISCARD Extent2D getRenderingAreaGranularityKHR( const RenderingAreaInfo & renderingAreaInfo,
17554 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17555 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17556
17557 // wrapper function for command vkGetDeviceImageSubresourceLayoutKHR, see
17558 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSubresourceLayoutKHR.html
17559 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17560 void getImageSubresourceLayoutKHR( const DeviceImageSubresourceInfo * pInfo,
17561 SubresourceLayout2 * pLayout,
17562 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17563 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17564 // wrapper function for command vkGetDeviceImageSubresourceLayoutKHR, see
17565 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSubresourceLayoutKHR.html
17566 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17567 VULKAN_HPP_NODISCARD SubresourceLayout2 getImageSubresourceLayoutKHR(
17568 const DeviceImageSubresourceInfo & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17569 // wrapper function for command vkGetDeviceImageSubresourceLayoutKHR, see
17570 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSubresourceLayoutKHR.html
17571 template <typename X,
17572 typename Y,
17573 typename... Z,
17574 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
17575 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17576 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
17577 getImageSubresourceLayoutKHR( const DeviceImageSubresourceInfo & info,
17578 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17579 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17580
17581 // wrapper function for command vkGetImageSubresourceLayout2KHR, see
17582 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2KHR.html
17583 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17584 void getImageSubresourceLayout2KHR( Image image,
17585 const ImageSubresource2 * pSubresource,
17586 SubresourceLayout2 * pLayout,
17587 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17588 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17589 // wrapper function for command vkGetImageSubresourceLayout2KHR, see
17590 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2KHR.html
17591 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17592 VULKAN_HPP_NODISCARD SubresourceLayout2 getImageSubresourceLayout2KHR(
17593 Image image, const ImageSubresource2 & subresource, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17594 // wrapper function for command vkGetImageSubresourceLayout2KHR, see
17595 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2KHR.html
17596 template <typename X,
17597 typename Y,
17598 typename... Z,
17599 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
17600 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17601 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getImageSubresourceLayout2KHR(
17602 Image image, const ImageSubresource2 & subresource, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17603 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17604
17605 //=== VK_AMD_anti_lag ===
17606
17607 // wrapper function for command vkAntiLagUpdateAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAntiLagUpdateAMD.html
17608 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17609 void antiLagUpdateAMD( const AntiLagDataAMD * pData, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17610 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17611 // wrapper function for command vkAntiLagUpdateAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAntiLagUpdateAMD.html
17612 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17613 void antiLagUpdateAMD( const AntiLagDataAMD & data, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17614 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17615
17616 //=== VK_KHR_present_wait2 ===
17617
17618 // wrapper function for command vkWaitForPresent2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitForPresent2KHR.html
17619 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17620 VULKAN_HPP_NODISCARD Result waitForPresent2KHR( SwapchainKHR swapchain,
17621 const PresentWait2InfoKHR * pPresentWait2Info,
17622 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17623 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17624 // wrapper function for command vkWaitForPresent2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitForPresent2KHR.html
17625 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17626 VULKAN_HPP_NODISCARD Result waitForPresent2KHR( SwapchainKHR swapchain,
17627 const PresentWait2InfoKHR & presentWait2Info,
17628 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17629 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17630
17631 //=== VK_EXT_shader_object ===
17632
17633 // wrapper function for command vkCreateShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShadersEXT.html
17634 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17635 VULKAN_HPP_NODISCARD Result createShadersEXT( uint32_t createInfoCount,
17636 const ShaderCreateInfoEXT * pCreateInfos,
17637 const AllocationCallbacks * pAllocator,
17638 ShaderEXT * pShaders,
17639 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17640 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17641 // wrapper function for command vkCreateShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShadersEXT.html
17642 template <typename ShaderEXTAllocator = std::allocator<ShaderEXT>,
17643 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
17644 typename std::enable_if<std::is_same<typename ShaderEXTAllocator::value_type, ShaderEXT>::value, int>::type = 0,
17645 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17646 VULKAN_HPP_NODISCARD ResultValue<std::vector<ShaderEXT, ShaderEXTAllocator>>
17647 createShadersEXT( ArrayProxy<const ShaderCreateInfoEXT> const & createInfos,
17648 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
17649 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17650 // wrapper function for command vkCreateShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShadersEXT.html
17651 template <typename ShaderEXTAllocator = std::allocator<ShaderEXT>,
17652 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
17653 typename std::enable_if<std::is_same<typename ShaderEXTAllocator::value_type, ShaderEXT>::value, int>::type = 0,
17654 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17655 VULKAN_HPP_NODISCARD ResultValue<std::vector<ShaderEXT, ShaderEXTAllocator>>
17656 createShadersEXT( ArrayProxy<const ShaderCreateInfoEXT> const & createInfos,
17657 Optional<const AllocationCallbacks> allocator,
17658 ShaderEXTAllocator & shaderEXTAllocator,
17659 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17660 // wrapper function for command vkCreateShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShadersEXT.html
17661 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17662 VULKAN_HPP_NODISCARD ResultValue<ShaderEXT> createShaderEXT( const ShaderCreateInfoEXT & createInfo,
17663 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
17664 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17665 # ifndef VULKAN_HPP_NO_SMART_HANDLE
17666 // wrapper function for command vkCreateShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShadersEXT.html
17667 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
17668 typename ShaderEXTAllocator = std::allocator<UniqueHandle<ShaderEXT, Dispatch>>,
17669 typename std::enable_if<std::is_same<typename ShaderEXTAllocator::value_type, UniqueHandle<ShaderEXT, Dispatch>>::value, int>::type = 0,
17670 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17671 VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<ShaderEXT, Dispatch>, ShaderEXTAllocator>>
17672 createShadersEXTUnique( ArrayProxy<const ShaderCreateInfoEXT> const & createInfos,
17673 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
17674 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17675 // wrapper function for command vkCreateShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShadersEXT.html
17676 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
17677 typename ShaderEXTAllocator = std::allocator<UniqueHandle<ShaderEXT, Dispatch>>,
17678 typename std::enable_if<std::is_same<typename ShaderEXTAllocator::value_type, UniqueHandle<ShaderEXT, Dispatch>>::value, int>::type = 0,
17679 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17680 VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<ShaderEXT, Dispatch>, ShaderEXTAllocator>>
17681 createShadersEXTUnique( ArrayProxy<const ShaderCreateInfoEXT> const & createInfos,
17682 Optional<const AllocationCallbacks> allocator,
17683 ShaderEXTAllocator & shaderEXTAllocator,
17684 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17685 // wrapper function for command vkCreateShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShadersEXT.html
17686 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17687 VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<ShaderEXT, Dispatch>>
17688 createShaderEXTUnique( const ShaderCreateInfoEXT & createInfo,
17689 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
17690 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17691 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
17692 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17693
17694 // wrapper function for command vkDestroyShaderEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyShaderEXT.html
17695 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17696 void destroyShaderEXT( ShaderEXT shader,
17697 const AllocationCallbacks * pAllocator,
17698 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17699 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17700 // wrapper function for command vkDestroyShaderEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyShaderEXT.html
17701 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17702 void destroyShaderEXT( ShaderEXT shader VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
17703 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
17704 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17705 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17706
17707 // wrapper function for command vkDestroyShaderEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyShaderEXT.html
17708 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17709 void destroy( ShaderEXT shader,
17710 const AllocationCallbacks * pAllocator,
17711 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17712 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17713 // wrapper function for command vkDestroyShaderEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyShaderEXT.html
17714 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17715 void destroy( ShaderEXT shader,
17716 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
17717 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17718 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17719
17720 // wrapper function for command vkGetShaderBinaryDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderBinaryDataEXT.html
17721 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17722 VULKAN_HPP_NODISCARD Result getShaderBinaryDataEXT( ShaderEXT shader,
17723 size_t * pDataSize,
17724 void * pData,
17725 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17726 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17727 // wrapper function for command vkGetShaderBinaryDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderBinaryDataEXT.html
17728 template <typename Uint8_tAllocator = std::allocator<uint8_t>,
17729 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
17730 typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0,
17731 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17732 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
17733 getShaderBinaryDataEXT( ShaderEXT shader, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17734 // wrapper function for command vkGetShaderBinaryDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderBinaryDataEXT.html
17735 template <typename Uint8_tAllocator = std::allocator<uint8_t>,
17736 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
17737 typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0,
17738 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17739 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
17740 getShaderBinaryDataEXT( ShaderEXT shader, Uint8_tAllocator & uint8_tAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17741 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17742
17743 //=== VK_KHR_pipeline_binary ===
17744
17745 // wrapper function for command vkCreatePipelineBinariesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineBinariesKHR.html
17746 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17747 VULKAN_HPP_NODISCARD Result createPipelineBinariesKHR( const PipelineBinaryCreateInfoKHR * pCreateInfo,
17748 const AllocationCallbacks * pAllocator,
17749 PipelineBinaryHandlesInfoKHR * pBinaries,
17750 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17751 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17752 // wrapper function for command vkCreatePipelineBinariesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineBinariesKHR.html
17753 template <typename PipelineBinaryKHRAllocator = std::allocator<PipelineBinaryKHR>,
17754 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
17755 typename std::enable_if<std::is_same<typename PipelineBinaryKHRAllocator::value_type, PipelineBinaryKHR>::value, int>::type = 0,
17756 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17757 VULKAN_HPP_NODISCARD ResultValue<std::vector<PipelineBinaryKHR, PipelineBinaryKHRAllocator>>
17758 createPipelineBinariesKHR( const PipelineBinaryCreateInfoKHR & createInfo,
17759 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
17760 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17761 // wrapper function for command vkCreatePipelineBinariesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineBinariesKHR.html
17762 template <typename PipelineBinaryKHRAllocator = std::allocator<PipelineBinaryKHR>,
17763 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
17764 typename std::enable_if<std::is_same<typename PipelineBinaryKHRAllocator::value_type, PipelineBinaryKHR>::value, int>::type = 0,
17765 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17766 VULKAN_HPP_NODISCARD ResultValue<std::vector<PipelineBinaryKHR, PipelineBinaryKHRAllocator>>
17767 createPipelineBinariesKHR( const PipelineBinaryCreateInfoKHR & createInfo,
17768 Optional<const AllocationCallbacks> allocator,
17769 PipelineBinaryKHRAllocator & pipelineBinaryKHRAllocator,
17770 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17771 # ifndef VULKAN_HPP_NO_SMART_HANDLE
17772 // wrapper function for command vkCreatePipelineBinariesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineBinariesKHR.html
17773 template <
17774 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
17775 typename PipelineBinaryKHRAllocator = std::allocator<UniqueHandle<PipelineBinaryKHR, Dispatch>>,
17776 typename std::enable_if<std::is_same<typename PipelineBinaryKHRAllocator::value_type, UniqueHandle<PipelineBinaryKHR, Dispatch>>::value, int>::type = 0,
17777 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17778 VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<PipelineBinaryKHR, Dispatch>, PipelineBinaryKHRAllocator>>
17779 createPipelineBinariesKHRUnique( const PipelineBinaryCreateInfoKHR & createInfo,
17780 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
17781 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17782 // wrapper function for command vkCreatePipelineBinariesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineBinariesKHR.html
17783 template <
17784 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
17785 typename PipelineBinaryKHRAllocator = std::allocator<UniqueHandle<PipelineBinaryKHR, Dispatch>>,
17786 typename std::enable_if<std::is_same<typename PipelineBinaryKHRAllocator::value_type, UniqueHandle<PipelineBinaryKHR, Dispatch>>::value, int>::type = 0,
17787 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17788 VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<PipelineBinaryKHR, Dispatch>, PipelineBinaryKHRAllocator>>
17789 createPipelineBinariesKHRUnique( const PipelineBinaryCreateInfoKHR & createInfo,
17790 Optional<const AllocationCallbacks> allocator,
17791 PipelineBinaryKHRAllocator & pipelineBinaryKHRAllocator,
17792 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17793 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
17794 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17795
17796 // wrapper function for command vkDestroyPipelineBinaryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineBinaryKHR.html
17797 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17798 void destroyPipelineBinaryKHR( PipelineBinaryKHR pipelineBinary,
17799 const AllocationCallbacks * pAllocator,
17800 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17801 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17802 // wrapper function for command vkDestroyPipelineBinaryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineBinaryKHR.html
17803 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17804 void destroyPipelineBinaryKHR( PipelineBinaryKHR pipelineBinary VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
17805 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
17806 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17807 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17808
17809 // wrapper function for command vkDestroyPipelineBinaryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineBinaryKHR.html
17810 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17811 void destroy( PipelineBinaryKHR pipelineBinary,
17812 const AllocationCallbacks * pAllocator,
17813 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17814 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17815 // wrapper function for command vkDestroyPipelineBinaryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineBinaryKHR.html
17816 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17817 void destroy( PipelineBinaryKHR pipelineBinary,
17818 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
17819 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17820 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17821
17822 // wrapper function for command vkGetPipelineKeyKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineKeyKHR.html
17823 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17824 VULKAN_HPP_NODISCARD Result getPipelineKeyKHR( const PipelineCreateInfoKHR * pPipelineCreateInfo,
17825 PipelineBinaryKeyKHR * pPipelineKey,
17826 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17827 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17828 // wrapper function for command vkGetPipelineKeyKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineKeyKHR.html
17829 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17830 VULKAN_HPP_NODISCARD typename ResultValueType<PipelineBinaryKeyKHR>::type
17831 getPipelineKeyKHR( Optional<const PipelineCreateInfoKHR> pipelineCreateInfo VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
17832 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17833 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17834
17835 // wrapper function for command vkGetPipelineBinaryDataKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineBinaryDataKHR.html
17836 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17837 VULKAN_HPP_NODISCARD Result getPipelineBinaryDataKHR( const PipelineBinaryDataInfoKHR * pInfo,
17838 PipelineBinaryKeyKHR * pPipelineBinaryKey,
17839 size_t * pPipelineBinaryDataSize,
17840 void * pPipelineBinaryData,
17841 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17842 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17843 // wrapper function for command vkGetPipelineBinaryDataKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineBinaryDataKHR.html
17844 template <typename Uint8_tAllocator = std::allocator<uint8_t>,
17845 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
17846 typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0,
17847 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17848 VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<PipelineBinaryKeyKHR, std::vector<uint8_t, Uint8_tAllocator>>>::type
17849 getPipelineBinaryDataKHR( const PipelineBinaryDataInfoKHR & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17850 // wrapper function for command vkGetPipelineBinaryDataKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineBinaryDataKHR.html
17851 template <typename Uint8_tAllocator = std::allocator<uint8_t>,
17852 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
17853 typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0,
17854 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17855 VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<PipelineBinaryKeyKHR, std::vector<uint8_t, Uint8_tAllocator>>>::type getPipelineBinaryDataKHR(
17856 const PipelineBinaryDataInfoKHR & info, Uint8_tAllocator & uint8_tAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17857 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17858
17859 // wrapper function for command vkReleaseCapturedPipelineDataKHR, see
17860 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseCapturedPipelineDataKHR.html
17861 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17862 VULKAN_HPP_NODISCARD Result releaseCapturedPipelineDataKHR( const ReleaseCapturedPipelineDataInfoKHR * pInfo,
17863 const AllocationCallbacks * pAllocator,
17864 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17865 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17866 // wrapper function for command vkReleaseCapturedPipelineDataKHR, see
17867 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseCapturedPipelineDataKHR.html
17868 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17869 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
17870 releaseCapturedPipelineDataKHR( const ReleaseCapturedPipelineDataInfoKHR & info,
17871 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
17872 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17873 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17874
17875 //=== VK_QCOM_tile_properties ===
17876
17877 // wrapper function for command vkGetFramebufferTilePropertiesQCOM, see
17878 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFramebufferTilePropertiesQCOM.html
17879 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17880 VULKAN_HPP_NODISCARD Result getFramebufferTilePropertiesQCOM( Framebuffer framebuffer,
17881 uint32_t * pPropertiesCount,
17882 TilePropertiesQCOM * pProperties,
17883 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17884 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17885 // wrapper function for command vkGetFramebufferTilePropertiesQCOM, see
17886 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFramebufferTilePropertiesQCOM.html
17887 template <typename TilePropertiesQCOMAllocator = std::allocator<TilePropertiesQCOM>,
17888 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
17889 typename std::enable_if<std::is_same<typename TilePropertiesQCOMAllocator::value_type, TilePropertiesQCOM>::value, int>::type = 0,
17890 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17891 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<TilePropertiesQCOM, TilePropertiesQCOMAllocator>>::type
17892 getFramebufferTilePropertiesQCOM( Framebuffer framebuffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17893 // wrapper function for command vkGetFramebufferTilePropertiesQCOM, see
17894 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFramebufferTilePropertiesQCOM.html
17895 template <typename TilePropertiesQCOMAllocator = std::allocator<TilePropertiesQCOM>,
17896 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
17897 typename std::enable_if<std::is_same<typename TilePropertiesQCOMAllocator::value_type, TilePropertiesQCOM>::value, int>::type = 0,
17898 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17899 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<TilePropertiesQCOM, TilePropertiesQCOMAllocator>>::type getFramebufferTilePropertiesQCOM(
17900 Framebuffer framebuffer, TilePropertiesQCOMAllocator & tilePropertiesQCOMAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17901 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17902
17903 // wrapper function for command vkGetDynamicRenderingTilePropertiesQCOM, see
17904 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDynamicRenderingTilePropertiesQCOM.html
17905 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17906 VULKAN_HPP_NODISCARD Result getDynamicRenderingTilePropertiesQCOM( const RenderingInfo * pRenderingInfo,
17907 TilePropertiesQCOM * pProperties,
17908 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17909 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17910 // wrapper function for command vkGetDynamicRenderingTilePropertiesQCOM, see
17911 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDynamicRenderingTilePropertiesQCOM.html
17912 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17913 VULKAN_HPP_NODISCARD typename ResultValueType<TilePropertiesQCOM>::type
17914 getDynamicRenderingTilePropertiesQCOM( const RenderingInfo & renderingInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17915 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17916
17917 //=== VK_KHR_swapchain_maintenance1 ===
17918
17919 // wrapper function for command vkReleaseSwapchainImagesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseSwapchainImagesKHR.html
17920 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17921 VULKAN_HPP_NODISCARD Result releaseSwapchainImagesKHR( const ReleaseSwapchainImagesInfoKHR * pReleaseInfo,
17922 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17923 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17924 // wrapper function for command vkReleaseSwapchainImagesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseSwapchainImagesKHR.html
17925 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17926 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
17927 releaseSwapchainImagesKHR( const ReleaseSwapchainImagesInfoKHR & releaseInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17928 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17929
17930 //=== VK_NV_cooperative_vector ===
17931
17932 // wrapper function for command vkConvertCooperativeVectorMatrixNV, see
17933 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkConvertCooperativeVectorMatrixNV.html
17934 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17935 VULKAN_HPP_NODISCARD Result convertCooperativeVectorMatrixNV( const ConvertCooperativeVectorMatrixInfoNV * pInfo,
17936 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17937 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17938 // wrapper function for command vkConvertCooperativeVectorMatrixNV, see
17939 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkConvertCooperativeVectorMatrixNV.html
17940 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17941 VULKAN_HPP_NODISCARD Result convertCooperativeVectorMatrixNV( const ConvertCooperativeVectorMatrixInfoNV & info,
17942 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17943 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17944
17945 //=== VK_NV_low_latency2 ===
17946
17947 // wrapper function for command vkSetLatencySleepModeNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetLatencySleepModeNV.html
17948 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17949 VULKAN_HPP_NODISCARD Result setLatencySleepModeNV( SwapchainKHR swapchain,
17950 const LatencySleepModeInfoNV * pSleepModeInfo,
17951 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17952 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17953 // wrapper function for command vkSetLatencySleepModeNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetLatencySleepModeNV.html
17954 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17955 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type setLatencySleepModeNV(
17956 SwapchainKHR swapchain, const LatencySleepModeInfoNV & sleepModeInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17957 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17958
17959 // wrapper function for command vkLatencySleepNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkLatencySleepNV.html
17960 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17961 VULKAN_HPP_NODISCARD Result latencySleepNV( SwapchainKHR swapchain,
17962 const LatencySleepInfoNV * pSleepInfo,
17963 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17964 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17965 // wrapper function for command vkLatencySleepNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkLatencySleepNV.html
17966 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17967 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
17968 latencySleepNV( SwapchainKHR swapchain, const LatencySleepInfoNV & sleepInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17969 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17970
17971 // wrapper function for command vkSetLatencyMarkerNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetLatencyMarkerNV.html
17972 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17973 void setLatencyMarkerNV( SwapchainKHR swapchain,
17974 const SetLatencyMarkerInfoNV * pLatencyMarkerInfo,
17975 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17976 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17977 // wrapper function for command vkSetLatencyMarkerNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetLatencyMarkerNV.html
17978 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17979 void setLatencyMarkerNV( SwapchainKHR swapchain,
17980 const SetLatencyMarkerInfoNV & latencyMarkerInfo,
17981 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17982 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17983
17984 // wrapper function for command vkGetLatencyTimingsNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetLatencyTimingsNV.html
17985 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17986 void getLatencyTimingsNV( SwapchainKHR swapchain,
17987 GetLatencyMarkerInfoNV * pLatencyMarkerInfo,
17988 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17989 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17990 // wrapper function for command vkGetLatencyTimingsNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetLatencyTimingsNV.html
17991 template <
17992 typename LatencyTimingsFrameReportNVAllocator = std::allocator<LatencyTimingsFrameReportNV>,
17993 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
17994 typename std::enable_if<std::is_same<typename LatencyTimingsFrameReportNVAllocator::value_type, LatencyTimingsFrameReportNV>::value, int>::type = 0,
17995 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
17996 VULKAN_HPP_NODISCARD std::vector<LatencyTimingsFrameReportNV, LatencyTimingsFrameReportNVAllocator>
17997 getLatencyTimingsNV( SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17998 // wrapper function for command vkGetLatencyTimingsNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetLatencyTimingsNV.html
17999 template <
18000 typename LatencyTimingsFrameReportNVAllocator = std::allocator<LatencyTimingsFrameReportNV>,
18001 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
18002 typename std::enable_if<std::is_same<typename LatencyTimingsFrameReportNVAllocator::value_type, LatencyTimingsFrameReportNV>::value, int>::type = 0,
18003 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18004 VULKAN_HPP_NODISCARD std::vector<LatencyTimingsFrameReportNV, LatencyTimingsFrameReportNVAllocator>
18005 getLatencyTimingsNV( SwapchainKHR swapchain,
18006 LatencyTimingsFrameReportNVAllocator & latencyTimingsFrameReportNVAllocator,
18007 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
18008 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
18009
18010 //=== VK_ARM_data_graph ===
18011
18012 // wrapper function for command vkCreateDataGraphPipelinesARM, see
18013 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelinesARM.html
18014 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18015 VULKAN_HPP_NODISCARD Result createDataGraphPipelinesARM( DeferredOperationKHR deferredOperation,
18016 PipelineCache pipelineCache,
18017 uint32_t createInfoCount,
18018 const DataGraphPipelineCreateInfoARM * pCreateInfos,
18019 const AllocationCallbacks * pAllocator,
18020 Pipeline * pPipelines,
18021 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
18022 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
18023 // wrapper function for command vkCreateDataGraphPipelinesARM, see
18024 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelinesARM.html
18025 template <typename PipelineAllocator = std::allocator<Pipeline>,
18026 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
18027 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, Pipeline>::value, int>::type = 0,
18028 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18029 VULKAN_HPP_NODISCARD ResultValue<std::vector<Pipeline, PipelineAllocator>>
18030 createDataGraphPipelinesARM( DeferredOperationKHR deferredOperation,
18031 PipelineCache pipelineCache,
18032 ArrayProxy<const DataGraphPipelineCreateInfoARM> const & createInfos,
18033 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
18034 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
18035 // wrapper function for command vkCreateDataGraphPipelinesARM, see
18036 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelinesARM.html
18037 template <typename PipelineAllocator = std::allocator<Pipeline>,
18038 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
18039 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, Pipeline>::value, int>::type = 0,
18040 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18041 VULKAN_HPP_NODISCARD ResultValue<std::vector<Pipeline, PipelineAllocator>>
18042 createDataGraphPipelinesARM( DeferredOperationKHR deferredOperation,
18043 PipelineCache pipelineCache,
18044 ArrayProxy<const DataGraphPipelineCreateInfoARM> const & createInfos,
18045 Optional<const AllocationCallbacks> allocator,
18046 PipelineAllocator & pipelineAllocator,
18047 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
18048 // wrapper function for command vkCreateDataGraphPipelinesARM, see
18049 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelinesARM.html
18050 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18051 VULKAN_HPP_NODISCARD ResultValue<Pipeline>
18052 createDataGraphPipelineARM( DeferredOperationKHR deferredOperation,
18053 PipelineCache pipelineCache,
18054 const DataGraphPipelineCreateInfoARM & createInfo,
18055 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
18056 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
18057 # ifndef VULKAN_HPP_NO_SMART_HANDLE
18058 // wrapper function for command vkCreateDataGraphPipelinesARM, see
18059 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelinesARM.html
18060 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
18061 typename PipelineAllocator = std::allocator<UniqueHandle<Pipeline, Dispatch>>,
18062 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<Pipeline, Dispatch>>::value, int>::type = 0,
18063 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18064 VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
18065 createDataGraphPipelinesARMUnique( DeferredOperationKHR deferredOperation,
18066 PipelineCache pipelineCache,
18067 ArrayProxy<const DataGraphPipelineCreateInfoARM> const & createInfos,
18068 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
18069 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
18070 // wrapper function for command vkCreateDataGraphPipelinesARM, see
18071 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelinesARM.html
18072 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
18073 typename PipelineAllocator = std::allocator<UniqueHandle<Pipeline, Dispatch>>,
18074 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<Pipeline, Dispatch>>::value, int>::type = 0,
18075 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18076 VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
18077 createDataGraphPipelinesARMUnique( DeferredOperationKHR deferredOperation,
18078 PipelineCache pipelineCache,
18079 ArrayProxy<const DataGraphPipelineCreateInfoARM> const & createInfos,
18080 Optional<const AllocationCallbacks> allocator,
18081 PipelineAllocator & pipelineAllocator,
18082 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
18083 // wrapper function for command vkCreateDataGraphPipelinesARM, see
18084 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelinesARM.html
18085 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18086 VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<Pipeline, Dispatch>>
18087 createDataGraphPipelineARMUnique( DeferredOperationKHR deferredOperation,
18088 PipelineCache pipelineCache,
18089 const DataGraphPipelineCreateInfoARM & createInfo,
18090 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
18091 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
18092 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
18093 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
18094
18095 // wrapper function for command vkCreateDataGraphPipelineSessionARM, see
18096 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelineSessionARM.html
18097 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18098 VULKAN_HPP_NODISCARD Result createDataGraphPipelineSessionARM( const DataGraphPipelineSessionCreateInfoARM * pCreateInfo,
18099 const AllocationCallbacks * pAllocator,
18100 DataGraphPipelineSessionARM * pSession,
18101 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
18102 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
18103 // wrapper function for command vkCreateDataGraphPipelineSessionARM, see
18104 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelineSessionARM.html
18105 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18106 VULKAN_HPP_NODISCARD typename ResultValueType<DataGraphPipelineSessionARM>::type
18107 createDataGraphPipelineSessionARM( const DataGraphPipelineSessionCreateInfoARM & createInfo,
18108 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
18109 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
18110 # ifndef VULKAN_HPP_NO_SMART_HANDLE
18111 // wrapper function for command vkCreateDataGraphPipelineSessionARM, see
18112 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelineSessionARM.html
18113 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18114 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<DataGraphPipelineSessionARM, Dispatch>>::type
18115 createDataGraphPipelineSessionARMUnique( const DataGraphPipelineSessionCreateInfoARM & createInfo,
18116 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
18117 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
18118 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
18119 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
18120
18121 // wrapper function for command vkGetDataGraphPipelineSessionBindPointRequirementsARM, see
18122 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineSessionBindPointRequirementsARM.html
18123 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18124 VULKAN_HPP_NODISCARD Result
18125 getDataGraphPipelineSessionBindPointRequirementsARM( const DataGraphPipelineSessionBindPointRequirementsInfoARM * pInfo,
18126 uint32_t * pBindPointRequirementCount,
18127 DataGraphPipelineSessionBindPointRequirementARM * pBindPointRequirements,
18128 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
18129 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
18130 // wrapper function for command vkGetDataGraphPipelineSessionBindPointRequirementsARM, see
18131 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineSessionBindPointRequirementsARM.html
18132 template <typename DataGraphPipelineSessionBindPointRequirementARMAllocator = std::allocator<DataGraphPipelineSessionBindPointRequirementARM>,
18133 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
18134 typename std::enable_if<std::is_same<typename DataGraphPipelineSessionBindPointRequirementARMAllocator::value_type,
18135 DataGraphPipelineSessionBindPointRequirementARM>::value,
18136 int>::type = 0,
18137 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18138 VULKAN_HPP_NODISCARD
18139 typename ResultValueType<std::vector<DataGraphPipelineSessionBindPointRequirementARM, DataGraphPipelineSessionBindPointRequirementARMAllocator>>::type
18140 getDataGraphPipelineSessionBindPointRequirementsARM( const DataGraphPipelineSessionBindPointRequirementsInfoARM & info,
18141 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
18142 // wrapper function for command vkGetDataGraphPipelineSessionBindPointRequirementsARM, see
18143 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineSessionBindPointRequirementsARM.html
18144 template <typename DataGraphPipelineSessionBindPointRequirementARMAllocator = std::allocator<DataGraphPipelineSessionBindPointRequirementARM>,
18145 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
18146 typename std::enable_if<std::is_same<typename DataGraphPipelineSessionBindPointRequirementARMAllocator::value_type,
18147 DataGraphPipelineSessionBindPointRequirementARM>::value,
18148 int>::type = 0,
18149 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18150 VULKAN_HPP_NODISCARD
18151 typename ResultValueType<std::vector<DataGraphPipelineSessionBindPointRequirementARM, DataGraphPipelineSessionBindPointRequirementARMAllocator>>::type
18152 getDataGraphPipelineSessionBindPointRequirementsARM(
18153 const DataGraphPipelineSessionBindPointRequirementsInfoARM & info,
18154 DataGraphPipelineSessionBindPointRequirementARMAllocator & dataGraphPipelineSessionBindPointRequirementARMAllocator,
18155 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
18156 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
18157
18158 // wrapper function for command vkGetDataGraphPipelineSessionMemoryRequirementsARM, see
18159 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineSessionMemoryRequirementsARM.html
18160 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18161 void getDataGraphPipelineSessionMemoryRequirementsARM( const DataGraphPipelineSessionMemoryRequirementsInfoARM * pInfo,
18162 MemoryRequirements2 * pMemoryRequirements,
18163 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
18164 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
18165 // wrapper function for command vkGetDataGraphPipelineSessionMemoryRequirementsARM, see
18166 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineSessionMemoryRequirementsARM.html
18167 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18168 VULKAN_HPP_NODISCARD MemoryRequirements2 getDataGraphPipelineSessionMemoryRequirementsARM(
18169 const DataGraphPipelineSessionMemoryRequirementsInfoARM & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
18170 // wrapper function for command vkGetDataGraphPipelineSessionMemoryRequirementsARM, see
18171 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineSessionMemoryRequirementsARM.html
18172 template <typename X,
18173 typename Y,
18174 typename... Z,
18175 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
18176 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18177 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
18178 getDataGraphPipelineSessionMemoryRequirementsARM( const DataGraphPipelineSessionMemoryRequirementsInfoARM & info,
18179 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
18180 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
18181
18182 // wrapper function for command vkBindDataGraphPipelineSessionMemoryARM, see
18183 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindDataGraphPipelineSessionMemoryARM.html
18184 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18185 VULKAN_HPP_NODISCARD Result bindDataGraphPipelineSessionMemoryARM( uint32_t bindInfoCount,
18186 const BindDataGraphPipelineSessionMemoryInfoARM * pBindInfos,
18187 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
18188 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
18189 // wrapper function for command vkBindDataGraphPipelineSessionMemoryARM, see
18190 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindDataGraphPipelineSessionMemoryARM.html
18191 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18192 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
18193 bindDataGraphPipelineSessionMemoryARM( ArrayProxy<const BindDataGraphPipelineSessionMemoryInfoARM> const & bindInfos,
18194 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
18195 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
18196
18197 // wrapper function for command vkDestroyDataGraphPipelineSessionARM, see
18198 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDataGraphPipelineSessionARM.html
18199 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18200 void destroyDataGraphPipelineSessionARM( DataGraphPipelineSessionARM session,
18201 const AllocationCallbacks * pAllocator,
18202 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
18203 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
18204 // wrapper function for command vkDestroyDataGraphPipelineSessionARM, see
18205 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDataGraphPipelineSessionARM.html
18206 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18207 void destroyDataGraphPipelineSessionARM( DataGraphPipelineSessionARM session,
18208 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
18209 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
18210 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
18211
18212 // wrapper function for command vkDestroyDataGraphPipelineSessionARM, see
18213 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDataGraphPipelineSessionARM.html
18214 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18215 void destroy( DataGraphPipelineSessionARM session,
18216 const AllocationCallbacks * pAllocator,
18217 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
18218 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
18219 // wrapper function for command vkDestroyDataGraphPipelineSessionARM, see
18220 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDataGraphPipelineSessionARM.html
18221 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18222 void destroy( DataGraphPipelineSessionARM session,
18223 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
18224 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
18225 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
18226
18227 // wrapper function for command vkGetDataGraphPipelineAvailablePropertiesARM, see
18228 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineAvailablePropertiesARM.html
18229 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18230 VULKAN_HPP_NODISCARD Result
18231 getDataGraphPipelineAvailablePropertiesARM( const DataGraphPipelineInfoARM * pPipelineInfo,
18232 uint32_t * pPropertiesCount,
18233 DataGraphPipelinePropertyARM * pProperties,
18234 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
18235 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
18236 // wrapper function for command vkGetDataGraphPipelineAvailablePropertiesARM, see
18237 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineAvailablePropertiesARM.html
18238 template <
18239 typename DataGraphPipelinePropertyARMAllocator = std::allocator<DataGraphPipelinePropertyARM>,
18240 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
18241 typename std::enable_if<std::is_same<typename DataGraphPipelinePropertyARMAllocator::value_type, DataGraphPipelinePropertyARM>::value, int>::type = 0,
18242 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18243 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataGraphPipelinePropertyARM, DataGraphPipelinePropertyARMAllocator>>::type
18244 getDataGraphPipelineAvailablePropertiesARM( const DataGraphPipelineInfoARM & pipelineInfo,
18245 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
18246 // wrapper function for command vkGetDataGraphPipelineAvailablePropertiesARM, see
18247 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineAvailablePropertiesARM.html
18248 template <
18249 typename DataGraphPipelinePropertyARMAllocator = std::allocator<DataGraphPipelinePropertyARM>,
18250 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
18251 typename std::enable_if<std::is_same<typename DataGraphPipelinePropertyARMAllocator::value_type, DataGraphPipelinePropertyARM>::value, int>::type = 0,
18252 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18253 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataGraphPipelinePropertyARM, DataGraphPipelinePropertyARMAllocator>>::type
18254 getDataGraphPipelineAvailablePropertiesARM( const DataGraphPipelineInfoARM & pipelineInfo,
18255 DataGraphPipelinePropertyARMAllocator & dataGraphPipelinePropertyARMAllocator,
18256 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
18257 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
18258
18259 // wrapper function for command vkGetDataGraphPipelinePropertiesARM, see
18260 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelinePropertiesARM.html
18261 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18262 VULKAN_HPP_NODISCARD Result getDataGraphPipelinePropertiesARM( const DataGraphPipelineInfoARM * pPipelineInfo,
18263 uint32_t propertiesCount,
18264 DataGraphPipelinePropertyQueryResultARM * pProperties,
18265 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
18266
18267 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
18268 //=== VK_QNX_external_memory_screen_buffer ===
18269
18270 // wrapper function for command vkGetScreenBufferPropertiesQNX, see
18271 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetScreenBufferPropertiesQNX.html
18272 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18273 VULKAN_HPP_NODISCARD Result getScreenBufferPropertiesQNX( const struct _screen_buffer * buffer,
18274 ScreenBufferPropertiesQNX * pProperties,
18275 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
18276 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
18277 // wrapper function for command vkGetScreenBufferPropertiesQNX, see
18278 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetScreenBufferPropertiesQNX.html
18279 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18280 VULKAN_HPP_NODISCARD typename ResultValueType<ScreenBufferPropertiesQNX>::type
18281 getScreenBufferPropertiesQNX( const struct _screen_buffer & buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
18282 // wrapper function for command vkGetScreenBufferPropertiesQNX, see
18283 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetScreenBufferPropertiesQNX.html
18284 template <typename X,
18285 typename Y,
18286 typename... Z,
18287 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
18288 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18289 VULKAN_HPP_NODISCARD typename ResultValueType<StructureChain<X, Y, Z...>>::type
18290 getScreenBufferPropertiesQNX( const struct _screen_buffer & buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
18291 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
18292 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
18293
18294 //=== VK_KHR_calibrated_timestamps ===
18295
18296 // wrapper function for command vkGetCalibratedTimestampsKHR, see
18297 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsKHR.html
18298 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18299 VULKAN_HPP_NODISCARD Result getCalibratedTimestampsKHR( uint32_t timestampCount,
18300 const CalibratedTimestampInfoKHR * pTimestampInfos,
18301 uint64_t * pTimestamps,
18302 uint64_t * pMaxDeviation,
18303 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
18304 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
18305 // wrapper function for command vkGetCalibratedTimestampsKHR, see
18306 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsKHR.html
18307 template <typename Uint64_tAllocator = std::allocator<uint64_t>,
18308 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
18309 typename std::enable_if<std::is_same<typename Uint64_tAllocator::value_type, uint64_t>::value, int>::type = 0,
18310 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18311 VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type
18312 getCalibratedTimestampsKHR( ArrayProxy<const CalibratedTimestampInfoKHR> const & timestampInfos,
18313 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
18314 // wrapper function for command vkGetCalibratedTimestampsKHR, see
18315 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsKHR.html
18316 template <typename Uint64_tAllocator = std::allocator<uint64_t>,
18317 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
18318 typename std::enable_if<std::is_same<typename Uint64_tAllocator::value_type, uint64_t>::value, int>::type = 0,
18319 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18320 VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type
18321 getCalibratedTimestampsKHR( ArrayProxy<const CalibratedTimestampInfoKHR> const & timestampInfos,
18322 Uint64_tAllocator & uint64_tAllocator,
18323 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
18324 // wrapper function for command vkGetCalibratedTimestampsKHR, see
18325 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsKHR.html
18326 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18327 VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<uint64_t, uint64_t>>::type
18328 getCalibratedTimestampKHR( const CalibratedTimestampInfoKHR & timestampInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
18329 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
18330
18331 //=== VK_NV_external_compute_queue ===
18332
18333 // wrapper function for command vkCreateExternalComputeQueueNV, see
18334 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExternalComputeQueueNV.html
18335 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18336 VULKAN_HPP_NODISCARD Result createExternalComputeQueueNV( const ExternalComputeQueueCreateInfoNV * pCreateInfo,
18337 const AllocationCallbacks * pAllocator,
18338 ExternalComputeQueueNV * pExternalQueue,
18339 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
18340 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
18341 // wrapper function for command vkCreateExternalComputeQueueNV, see
18342 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExternalComputeQueueNV.html
18343 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18344 VULKAN_HPP_NODISCARD typename ResultValueType<ExternalComputeQueueNV>::type
18345 createExternalComputeQueueNV( const ExternalComputeQueueCreateInfoNV & createInfo,
18346 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
18347 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
18348 # ifndef VULKAN_HPP_NO_SMART_HANDLE
18349 // wrapper function for command vkCreateExternalComputeQueueNV, see
18350 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExternalComputeQueueNV.html
18351 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18352 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<ExternalComputeQueueNV, Dispatch>>::type
18353 createExternalComputeQueueNVUnique( const ExternalComputeQueueCreateInfoNV & createInfo,
18354 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
18355 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
18356 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
18357 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
18358
18359 // wrapper function for command vkDestroyExternalComputeQueueNV, see
18360 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyExternalComputeQueueNV.html
18361 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18362 void destroyExternalComputeQueueNV( ExternalComputeQueueNV externalQueue,
18363 const AllocationCallbacks * pAllocator,
18364 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
18365 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
18366 // wrapper function for command vkDestroyExternalComputeQueueNV, see
18367 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyExternalComputeQueueNV.html
18368 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18369 void destroyExternalComputeQueueNV( ExternalComputeQueueNV externalQueue,
18370 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
18371 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
18372 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
18373
18374 // wrapper function for command vkDestroyExternalComputeQueueNV, see
18375 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyExternalComputeQueueNV.html
18376 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18377 void destroy( ExternalComputeQueueNV externalQueue,
18378 const AllocationCallbacks * pAllocator,
18379 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
18380 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
18381 // wrapper function for command vkDestroyExternalComputeQueueNV, see
18382 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyExternalComputeQueueNV.html
18383 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18384 void destroy( ExternalComputeQueueNV externalQueue,
18385 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
18386 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
18387 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
18388
18389 //=== VK_NV_cluster_acceleration_structure ===
18390
18391 // wrapper function for command vkGetClusterAccelerationStructureBuildSizesNV, see
18392 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetClusterAccelerationStructureBuildSizesNV.html
18393 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18394 void getClusterAccelerationStructureBuildSizesNV( const ClusterAccelerationStructureInputInfoNV * pInfo,
18395 AccelerationStructureBuildSizesInfoKHR * pSizeInfo,
18396 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
18397 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
18398 // wrapper function for command vkGetClusterAccelerationStructureBuildSizesNV, see
18399 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetClusterAccelerationStructureBuildSizesNV.html
18400 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18401 VULKAN_HPP_NODISCARD AccelerationStructureBuildSizesInfoKHR getClusterAccelerationStructureBuildSizesNV(
18402 const ClusterAccelerationStructureInputInfoNV & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
18403 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
18404
18405 //=== VK_NV_partitioned_acceleration_structure ===
18406
18407 // wrapper function for command vkGetPartitionedAccelerationStructuresBuildSizesNV, see
18408 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPartitionedAccelerationStructuresBuildSizesNV.html
18409 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18410 void getPartitionedAccelerationStructuresBuildSizesNV( const PartitionedAccelerationStructureInstancesInputNV * pInfo,
18411 AccelerationStructureBuildSizesInfoKHR * pSizeInfo,
18412 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
18413 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
18414 // wrapper function for command vkGetPartitionedAccelerationStructuresBuildSizesNV, see
18415 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPartitionedAccelerationStructuresBuildSizesNV.html
18416 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18417 VULKAN_HPP_NODISCARD AccelerationStructureBuildSizesInfoKHR getPartitionedAccelerationStructuresBuildSizesNV(
18418 const PartitionedAccelerationStructureInstancesInputNV & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
18419 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
18420
18421 //=== VK_EXT_device_generated_commands ===
18422
18423 // wrapper function for command vkGetGeneratedCommandsMemoryRequirementsEXT, see
18424 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGeneratedCommandsMemoryRequirementsEXT.html
18425 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18426 void getGeneratedCommandsMemoryRequirementsEXT( const GeneratedCommandsMemoryRequirementsInfoEXT * pInfo,
18427 MemoryRequirements2 * pMemoryRequirements,
18428 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
18429 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
18430 // wrapper function for command vkGetGeneratedCommandsMemoryRequirementsEXT, see
18431 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGeneratedCommandsMemoryRequirementsEXT.html
18432 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18433 VULKAN_HPP_NODISCARD MemoryRequirements2 getGeneratedCommandsMemoryRequirementsEXT(
18434 const GeneratedCommandsMemoryRequirementsInfoEXT & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
18435 // wrapper function for command vkGetGeneratedCommandsMemoryRequirementsEXT, see
18436 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGeneratedCommandsMemoryRequirementsEXT.html
18437 template <typename X,
18438 typename Y,
18439 typename... Z,
18440 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
18441 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18442 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
18443 getGeneratedCommandsMemoryRequirementsEXT( const GeneratedCommandsMemoryRequirementsInfoEXT & info,
18444 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
18445 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
18446
18447 // wrapper function for command vkCreateIndirectCommandsLayoutEXT, see
18448 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectCommandsLayoutEXT.html
18449 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18450 VULKAN_HPP_NODISCARD Result createIndirectCommandsLayoutEXT( const IndirectCommandsLayoutCreateInfoEXT * pCreateInfo,
18451 const AllocationCallbacks * pAllocator,
18452 IndirectCommandsLayoutEXT * pIndirectCommandsLayout,
18453 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
18454 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
18455 // wrapper function for command vkCreateIndirectCommandsLayoutEXT, see
18456 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectCommandsLayoutEXT.html
18457 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18458 VULKAN_HPP_NODISCARD typename ResultValueType<IndirectCommandsLayoutEXT>::type
18459 createIndirectCommandsLayoutEXT( const IndirectCommandsLayoutCreateInfoEXT & createInfo,
18460 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
18461 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
18462 # ifndef VULKAN_HPP_NO_SMART_HANDLE
18463 // wrapper function for command vkCreateIndirectCommandsLayoutEXT, see
18464 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectCommandsLayoutEXT.html
18465 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18466 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<IndirectCommandsLayoutEXT, Dispatch>>::type
18467 createIndirectCommandsLayoutEXTUnique( const IndirectCommandsLayoutCreateInfoEXT & createInfo,
18468 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
18469 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
18470 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
18471 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
18472
18473 // wrapper function for command vkDestroyIndirectCommandsLayoutEXT, see
18474 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectCommandsLayoutEXT.html
18475 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18476 void destroyIndirectCommandsLayoutEXT( IndirectCommandsLayoutEXT indirectCommandsLayout,
18477 const AllocationCallbacks * pAllocator,
18478 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
18479 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
18480 // wrapper function for command vkDestroyIndirectCommandsLayoutEXT, see
18481 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectCommandsLayoutEXT.html
18482 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18483 void destroyIndirectCommandsLayoutEXT( IndirectCommandsLayoutEXT indirectCommandsLayout VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
18484 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
18485 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
18486 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
18487
18488 // wrapper function for command vkDestroyIndirectCommandsLayoutEXT, see
18489 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectCommandsLayoutEXT.html
18490 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18491 void destroy( IndirectCommandsLayoutEXT indirectCommandsLayout,
18492 const AllocationCallbacks * pAllocator,
18493 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
18494 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
18495 // wrapper function for command vkDestroyIndirectCommandsLayoutEXT, see
18496 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectCommandsLayoutEXT.html
18497 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18498 void destroy( IndirectCommandsLayoutEXT indirectCommandsLayout,
18499 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
18500 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
18501 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
18502
18503 // wrapper function for command vkCreateIndirectExecutionSetEXT, see
18504 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectExecutionSetEXT.html
18505 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18506 VULKAN_HPP_NODISCARD Result createIndirectExecutionSetEXT( const IndirectExecutionSetCreateInfoEXT * pCreateInfo,
18507 const AllocationCallbacks * pAllocator,
18508 IndirectExecutionSetEXT * pIndirectExecutionSet,
18509 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
18510 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
18511 // wrapper function for command vkCreateIndirectExecutionSetEXT, see
18512 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectExecutionSetEXT.html
18513 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18514 VULKAN_HPP_NODISCARD typename ResultValueType<IndirectExecutionSetEXT>::type
18515 createIndirectExecutionSetEXT( const IndirectExecutionSetCreateInfoEXT & createInfo,
18516 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
18517 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
18518 # ifndef VULKAN_HPP_NO_SMART_HANDLE
18519 // wrapper function for command vkCreateIndirectExecutionSetEXT, see
18520 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectExecutionSetEXT.html
18521 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18522 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<IndirectExecutionSetEXT, Dispatch>>::type
18523 createIndirectExecutionSetEXTUnique( const IndirectExecutionSetCreateInfoEXT & createInfo,
18524 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
18525 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
18526 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
18527 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
18528
18529 // wrapper function for command vkDestroyIndirectExecutionSetEXT, see
18530 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectExecutionSetEXT.html
18531 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18532 void destroyIndirectExecutionSetEXT( IndirectExecutionSetEXT indirectExecutionSet,
18533 const AllocationCallbacks * pAllocator,
18534 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
18535 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
18536 // wrapper function for command vkDestroyIndirectExecutionSetEXT, see
18537 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectExecutionSetEXT.html
18538 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18539 void destroyIndirectExecutionSetEXT( IndirectExecutionSetEXT indirectExecutionSet VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
18540 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
18541 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
18542 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
18543
18544 // wrapper function for command vkDestroyIndirectExecutionSetEXT, see
18545 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectExecutionSetEXT.html
18546 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18547 void destroy( IndirectExecutionSetEXT indirectExecutionSet,
18548 const AllocationCallbacks * pAllocator,
18549 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
18550 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
18551 // wrapper function for command vkDestroyIndirectExecutionSetEXT, see
18552 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectExecutionSetEXT.html
18553 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18554 void destroy( IndirectExecutionSetEXT indirectExecutionSet,
18555 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
18556 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
18557 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
18558
18559 // wrapper function for command vkUpdateIndirectExecutionSetPipelineEXT, see
18560 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateIndirectExecutionSetPipelineEXT.html
18561 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18562 void updateIndirectExecutionSetPipelineEXT( IndirectExecutionSetEXT indirectExecutionSet,
18563 uint32_t executionSetWriteCount,
18564 const WriteIndirectExecutionSetPipelineEXT * pExecutionSetWrites,
18565 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
18566 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
18567 // wrapper function for command vkUpdateIndirectExecutionSetPipelineEXT, see
18568 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateIndirectExecutionSetPipelineEXT.html
18569 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18570 void updateIndirectExecutionSetPipelineEXT( IndirectExecutionSetEXT indirectExecutionSet,
18571 ArrayProxy<const WriteIndirectExecutionSetPipelineEXT> const & executionSetWrites,
18572 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
18573 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
18574
18575 // wrapper function for command vkUpdateIndirectExecutionSetShaderEXT, see
18576 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateIndirectExecutionSetShaderEXT.html
18577 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18578 void updateIndirectExecutionSetShaderEXT( IndirectExecutionSetEXT indirectExecutionSet,
18579 uint32_t executionSetWriteCount,
18580 const WriteIndirectExecutionSetShaderEXT * pExecutionSetWrites,
18581 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
18582 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
18583 // wrapper function for command vkUpdateIndirectExecutionSetShaderEXT, see
18584 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateIndirectExecutionSetShaderEXT.html
18585 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18586 void updateIndirectExecutionSetShaderEXT( IndirectExecutionSetEXT indirectExecutionSet,
18587 ArrayProxy<const WriteIndirectExecutionSetShaderEXT> const & executionSetWrites,
18588 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
18589 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
18590
18591 #if defined( VK_USE_PLATFORM_OHOS )
18592 //=== VK_OHOS_native_buffer ===
18593
18594 // wrapper function for command vkGetSwapchainGrallocUsageOHOS, see
18595 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainGrallocUsageOHOS.html
18596 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18597 VULKAN_HPP_NODISCARD Result getSwapchainGrallocUsageOHOS( Format format,
18598 ImageUsageFlags imageUsage,
18599 uint64_t * grallocUsage,
18600 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
18601 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
18602 // wrapper function for command vkGetSwapchainGrallocUsageOHOS, see
18603 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainGrallocUsageOHOS.html
18604 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18605 VULKAN_HPP_NODISCARD typename ResultValueType<uint64_t>::type
18606 getSwapchainGrallocUsageOHOS( Format format, ImageUsageFlags imageUsage, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
18607 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
18608
18609 # ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
18610 // wrapper function for command vkAcquireImageOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireImageOHOS.html
18611 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18612 VULKAN_HPP_NODISCARD Result acquireImageOHOS( Image image,
18613 int32_t nativeFenceFd,
18614 Semaphore semaphore,
18615 Fence fence,
18616 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
18617 # else
18618 // wrapper function for command vkAcquireImageOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireImageOHOS.html
18619 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18620 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
18621 acquireImageOHOS( Image image,
18622 int32_t nativeFenceFd,
18623 Semaphore semaphore VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
18624 Fence fence VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
18625 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
18626 # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
18627 #endif /*VK_USE_PLATFORM_OHOS*/
18628
18629 #if defined( VK_USE_PLATFORM_METAL_EXT )
18630 //=== VK_EXT_external_memory_metal ===
18631
18632 // wrapper function for command vkGetMemoryMetalHandleEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryMetalHandleEXT.html
18633 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18634 VULKAN_HPP_NODISCARD Result getMemoryMetalHandleEXT( const MemoryGetMetalHandleInfoEXT * pGetMetalHandleInfo,
18635 void ** pHandle,
18636 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
18637 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
18638 // wrapper function for command vkGetMemoryMetalHandleEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryMetalHandleEXT.html
18639 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18640 VULKAN_HPP_NODISCARD typename ResultValueType<void *>::type getMemoryMetalHandleEXT( const MemoryGetMetalHandleInfoEXT & getMetalHandleInfo,
18641 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
18642 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
18643
18644 // wrapper function for command vkGetMemoryMetalHandlePropertiesEXT, see
18645 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryMetalHandlePropertiesEXT.html
18646 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18647 VULKAN_HPP_NODISCARD Result getMemoryMetalHandlePropertiesEXT( ExternalMemoryHandleTypeFlagBits handleType,
18648 const void * pHandle,
18649 MemoryMetalHandlePropertiesEXT * pMemoryMetalHandleProperties,
18650 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
18651 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
18652 // wrapper function for command vkGetMemoryMetalHandlePropertiesEXT, see
18653 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryMetalHandlePropertiesEXT.html
18654 template <typename HandleType,
18655 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
18656 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18657 VULKAN_HPP_NODISCARD typename ResultValueType<MemoryMetalHandlePropertiesEXT>::type getMemoryMetalHandlePropertiesEXT(
18658 ExternalMemoryHandleTypeFlagBits handleType, HandleType const & handle, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
18659 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
18660 #endif /*VK_USE_PLATFORM_METAL_EXT*/
18661
18662 operator VkDevice() const VULKAN_HPP_NOEXCEPT
18663 {
18664 return m_device;
18665 }
18666
18667 explicit operator bool() const VULKAN_HPP_NOEXCEPT
18668 {
18669 return m_device != VK_NULL_HANDLE;
18670 }
18671
18672 bool operator!() const VULKAN_HPP_NOEXCEPT
18673 {
18674 return m_device == VK_NULL_HANDLE;
18675 }
18676
18677 private:
18678 VkDevice m_device = {};
18679 };
18680
18681 template <>
18682 struct CppType<ObjectType, ObjectType::eDevice>
18683 {
18684 using Type = Device;
18685 };
18686
18687 template <>
18688 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eDevice>
18689 {
18690 using Type = Device;
18691 };
18692
18693 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
18694 template <>
18695 struct CppType<VkDevice, VK_NULL_HANDLE>
18696 {
18697 using Type = Device;
18698 };
18699 #endif
18700
18701 template <>
18702 struct isVulkanHandleType<Device>
18703 {
18704 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
18705 };
18706
18707 // wrapper class for handle VkDisplayModeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplayModeKHR.html
18708 class DisplayModeKHR
18709 {
18710 public:
18711 using CType = VkDisplayModeKHR;
18712 using NativeType = VkDisplayModeKHR;
18713
18714 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDisplayModeKHR;
18715 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eDisplayModeKHR;
18716
18717 public:
18718 DisplayModeKHR() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
18719
18720 DisplayModeKHR( DisplayModeKHR const & rhs ) = default;
18721 DisplayModeKHR & operator=( DisplayModeKHR const & rhs ) = default;
18722
18723 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
18724 DisplayModeKHR( DisplayModeKHR && rhs ) = default;
18725 DisplayModeKHR & operator=( DisplayModeKHR && rhs ) = default;
18726 #else
18727 DisplayModeKHR( DisplayModeKHR && rhs ) VULKAN_HPP_NOEXCEPT : m_displayModeKHR( exchange( rhs.m_displayModeKHR, {} ) ) {}
18728
18729 DisplayModeKHR & operator=( DisplayModeKHR && rhs ) VULKAN_HPP_NOEXCEPT
18730 {
18731 m_displayModeKHR = exchange( rhs.m_displayModeKHR, {} );
18732 return *this;
18733 }
18734 #endif
18735
18736 VULKAN_HPP_CONSTEXPR DisplayModeKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
18737
18738 VULKAN_HPP_TYPESAFE_EXPLICIT DisplayModeKHR( VkDisplayModeKHR displayModeKHR ) VULKAN_HPP_NOEXCEPT : m_displayModeKHR( displayModeKHR ) {}
18739
18740 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
18741 DisplayModeKHR & operator=( VkDisplayModeKHR displayModeKHR ) VULKAN_HPP_NOEXCEPT
18742 {
18743 m_displayModeKHR = displayModeKHR;
18744 return *this;
18745 }
18746 #endif
18747
18748 DisplayModeKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
18749 {
18750 m_displayModeKHR = {};
18751 return *this;
18752 }
18753
18754 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDisplayModeKHR() const VULKAN_HPP_NOEXCEPT
18755 {
18756 return m_displayModeKHR;
18757 }
18758
18759 explicit operator bool() const VULKAN_HPP_NOEXCEPT
18760 {
18761 return m_displayModeKHR != VK_NULL_HANDLE;
18762 }
18763
18764 bool operator!() const VULKAN_HPP_NOEXCEPT
18765 {
18766 return m_displayModeKHR == VK_NULL_HANDLE;
18767 }
18768
18769 private:
18770 VkDisplayModeKHR m_displayModeKHR = {};
18771 };
18772
18773 template <>
18774 struct CppType<ObjectType, ObjectType::eDisplayModeKHR>
18775 {
18776 using Type = DisplayModeKHR;
18777 };
18778
18779 template <>
18780 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eDisplayModeKHR>
18781 {
18782 using Type = DisplayModeKHR;
18783 };
18784
18785 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
18786 template <>
18787 struct CppType<VkDisplayModeKHR, VK_NULL_HANDLE>
18788 {
18789 using Type = DisplayModeKHR;
18790 };
18791 #endif
18792
18793 template <>
18794 struct isVulkanHandleType<DisplayModeKHR>
18795 {
18796 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
18797 };
18798
18799 // wrapper class for handle VkPhysicalDevice, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevice.html
18800 class PhysicalDevice
18801 {
18802 public:
18803 using CType = VkPhysicalDevice;
18804 using NativeType = VkPhysicalDevice;
18805
18806 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePhysicalDevice;
18807 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::ePhysicalDevice;
18808
18809 public:
18810 PhysicalDevice() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
18811
18812 PhysicalDevice( PhysicalDevice const & rhs ) = default;
18813 PhysicalDevice & operator=( PhysicalDevice const & rhs ) = default;
18814
18815 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
18816 PhysicalDevice( PhysicalDevice && rhs ) = default;
18817 PhysicalDevice & operator=( PhysicalDevice && rhs ) = default;
18818 #else
18819 PhysicalDevice( PhysicalDevice && rhs ) VULKAN_HPP_NOEXCEPT : m_physicalDevice( exchange( rhs.m_physicalDevice, {} ) ) {}
18820
18821 PhysicalDevice & operator=( PhysicalDevice && rhs ) VULKAN_HPP_NOEXCEPT
18822 {
18823 m_physicalDevice = exchange( rhs.m_physicalDevice, {} );
18824 return *this;
18825 }
18826 #endif
18827
18828 VULKAN_HPP_CONSTEXPR PhysicalDevice( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
18829
18830 PhysicalDevice( VkPhysicalDevice physicalDevice ) VULKAN_HPP_NOEXCEPT : m_physicalDevice( physicalDevice ) {}
18831
18832 PhysicalDevice & operator=( VkPhysicalDevice physicalDevice ) VULKAN_HPP_NOEXCEPT
18833 {
18834 m_physicalDevice = physicalDevice;
18835 return *this;
18836 }
18837
18838 PhysicalDevice & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
18839 {
18840 m_physicalDevice = {};
18841 return *this;
18842 }
18843
18844 //=== VK_VERSION_1_0 ===
18845
18846 // wrapper function for command vkGetPhysicalDeviceFeatures, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures.html
18847 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18848 void getFeatures( PhysicalDeviceFeatures * pFeatures, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
18849 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
18850 // wrapper function for command vkGetPhysicalDeviceFeatures, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures.html
18851 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18852 VULKAN_HPP_NODISCARD PhysicalDeviceFeatures getFeatures( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
18853 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
18854
18855 // wrapper function for command vkGetPhysicalDeviceFormatProperties, see
18856 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties.html
18857 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18858 void getFormatProperties( Format format,
18859 FormatProperties * pFormatProperties,
18860 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
18861 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
18862 // wrapper function for command vkGetPhysicalDeviceFormatProperties, see
18863 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties.html
18864 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18865 VULKAN_HPP_NODISCARD FormatProperties getFormatProperties( Format format,
18866 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
18867 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
18868
18869 // wrapper function for command vkGetPhysicalDeviceImageFormatProperties, see
18870 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties.html
18871 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18872 VULKAN_HPP_NODISCARD Result getImageFormatProperties( Format format,
18873 ImageType type,
18874 ImageTiling tiling,
18875 ImageUsageFlags usage,
18876 ImageCreateFlags flags,
18877 ImageFormatProperties * pImageFormatProperties,
18878 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
18879 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
18880 // wrapper function for command vkGetPhysicalDeviceImageFormatProperties, see
18881 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties.html
18882 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18883 VULKAN_HPP_NODISCARD typename ResultValueType<ImageFormatProperties>::type
18884 getImageFormatProperties( Format format,
18885 ImageType type,
18886 ImageTiling tiling,
18887 ImageUsageFlags usage,
18888 ImageCreateFlags flags VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
18889 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
18890 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
18891
18892 // wrapper function for command vkGetPhysicalDeviceProperties, see
18893 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties.html
18894 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18895 void getProperties( PhysicalDeviceProperties * pProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
18896 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
18897 // wrapper function for command vkGetPhysicalDeviceProperties, see
18898 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties.html
18899 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18900 VULKAN_HPP_NODISCARD PhysicalDeviceProperties getProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
18901 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
18902
18903 // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties, see
18904 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties.html
18905 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18906 void getQueueFamilyProperties( uint32_t * pQueueFamilyPropertyCount,
18907 QueueFamilyProperties * pQueueFamilyProperties,
18908 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
18909 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
18910 // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties, see
18911 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties.html
18912 template <typename QueueFamilyPropertiesAllocator = std::allocator<QueueFamilyProperties>,
18913 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
18914 typename std::enable_if<std::is_same<typename QueueFamilyPropertiesAllocator::value_type, QueueFamilyProperties>::value, int>::type = 0,
18915 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18916 VULKAN_HPP_NODISCARD std::vector<QueueFamilyProperties, QueueFamilyPropertiesAllocator>
18917 getQueueFamilyProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
18918 // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties, see
18919 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties.html
18920 template <typename QueueFamilyPropertiesAllocator = std::allocator<QueueFamilyProperties>,
18921 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
18922 typename std::enable_if<std::is_same<typename QueueFamilyPropertiesAllocator::value_type, QueueFamilyProperties>::value, int>::type = 0,
18923 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18924 VULKAN_HPP_NODISCARD std::vector<QueueFamilyProperties, QueueFamilyPropertiesAllocator>
18925 getQueueFamilyProperties( QueueFamilyPropertiesAllocator & queueFamilyPropertiesAllocator,
18926 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
18927 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
18928
18929 // wrapper function for command vkGetPhysicalDeviceMemoryProperties, see
18930 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties.html
18931 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18932 void getMemoryProperties( PhysicalDeviceMemoryProperties * pMemoryProperties,
18933 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
18934 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
18935 // wrapper function for command vkGetPhysicalDeviceMemoryProperties, see
18936 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties.html
18937 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18938 VULKAN_HPP_NODISCARD PhysicalDeviceMemoryProperties
18939 getMemoryProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
18940 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
18941
18942 // wrapper function for command vkCreateDevice, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDevice.html
18943 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18944 VULKAN_HPP_NODISCARD Result createDevice( const DeviceCreateInfo * pCreateInfo,
18945 const AllocationCallbacks * pAllocator,
18946 Device * pDevice,
18947 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
18948 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
18949 // wrapper function for command vkCreateDevice, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDevice.html
18950 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18951 VULKAN_HPP_NODISCARD typename ResultValueType<Device>::type
18952 createDevice( const DeviceCreateInfo & createInfo,
18953 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
18954 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
18955 # ifndef VULKAN_HPP_NO_SMART_HANDLE
18956 // wrapper function for command vkCreateDevice, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDevice.html
18957 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18958 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<Device, Dispatch>>::type
18959 createDeviceUnique( const DeviceCreateInfo & createInfo,
18960 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
18961 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
18962 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
18963 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
18964
18965 // wrapper function for command vkEnumerateDeviceExtensionProperties, see
18966 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateDeviceExtensionProperties.html
18967 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18968 VULKAN_HPP_NODISCARD Result enumerateDeviceExtensionProperties( const char * pLayerName,
18969 uint32_t * pPropertyCount,
18970 ExtensionProperties * pProperties,
18971 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
18972 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
18973 // wrapper function for command vkEnumerateDeviceExtensionProperties, see
18974 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateDeviceExtensionProperties.html
18975 template <typename ExtensionPropertiesAllocator = std::allocator<ExtensionProperties>,
18976 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
18977 typename std::enable_if<std::is_same<typename ExtensionPropertiesAllocator::value_type, ExtensionProperties>::value, int>::type = 0,
18978 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18979 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<ExtensionProperties, ExtensionPropertiesAllocator>>::type
18980 enumerateDeviceExtensionProperties( Optional<const std::string> layerName VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
18981 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
18982 // wrapper function for command vkEnumerateDeviceExtensionProperties, see
18983 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateDeviceExtensionProperties.html
18984 template <typename ExtensionPropertiesAllocator = std::allocator<ExtensionProperties>,
18985 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
18986 typename std::enable_if<std::is_same<typename ExtensionPropertiesAllocator::value_type, ExtensionProperties>::value, int>::type = 0,
18987 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18988 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<ExtensionProperties, ExtensionPropertiesAllocator>>::type
18989 enumerateDeviceExtensionProperties( Optional<const std::string> layerName,
18990 ExtensionPropertiesAllocator & extensionPropertiesAllocator,
18991 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
18992 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
18993
18994 // wrapper function for command vkEnumerateDeviceLayerProperties, see
18995 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateDeviceLayerProperties.html
18996 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
18997 VULKAN_HPP_NODISCARD Result enumerateDeviceLayerProperties( uint32_t * pPropertyCount,
18998 LayerProperties * pProperties,
18999 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19000 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
19001 // wrapper function for command vkEnumerateDeviceLayerProperties, see
19002 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateDeviceLayerProperties.html
19003 template <typename LayerPropertiesAllocator = std::allocator<LayerProperties>,
19004 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
19005 typename std::enable_if<std::is_same<typename LayerPropertiesAllocator::value_type, LayerProperties>::value, int>::type = 0,
19006 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19007 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<LayerProperties, LayerPropertiesAllocator>>::type
19008 enumerateDeviceLayerProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
19009 // wrapper function for command vkEnumerateDeviceLayerProperties, see
19010 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateDeviceLayerProperties.html
19011 template <typename LayerPropertiesAllocator = std::allocator<LayerProperties>,
19012 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
19013 typename std::enable_if<std::is_same<typename LayerPropertiesAllocator::value_type, LayerProperties>::value, int>::type = 0,
19014 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19015 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<LayerProperties, LayerPropertiesAllocator>>::type
19016 enumerateDeviceLayerProperties( LayerPropertiesAllocator & layerPropertiesAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
19017 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
19018
19019 // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties, see
19020 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties.html
19021 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19022 void getSparseImageFormatProperties( Format format,
19023 ImageType type,
19024 SampleCountFlagBits samples,
19025 ImageUsageFlags usage,
19026 ImageTiling tiling,
19027 uint32_t * pPropertyCount,
19028 SparseImageFormatProperties * pProperties,
19029 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19030 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
19031 // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties, see
19032 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties.html
19033 template <
19034 typename SparseImageFormatPropertiesAllocator = std::allocator<SparseImageFormatProperties>,
19035 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
19036 typename std::enable_if<std::is_same<typename SparseImageFormatPropertiesAllocator::value_type, SparseImageFormatProperties>::value, int>::type = 0,
19037 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19038 VULKAN_HPP_NODISCARD std::vector<SparseImageFormatProperties, SparseImageFormatPropertiesAllocator>
19039 getSparseImageFormatProperties( Format format,
19040 ImageType type,
19041 SampleCountFlagBits samples,
19042 ImageUsageFlags usage,
19043 ImageTiling tiling,
19044 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
19045 // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties, see
19046 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties.html
19047 template <
19048 typename SparseImageFormatPropertiesAllocator = std::allocator<SparseImageFormatProperties>,
19049 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
19050 typename std::enable_if<std::is_same<typename SparseImageFormatPropertiesAllocator::value_type, SparseImageFormatProperties>::value, int>::type = 0,
19051 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19052 VULKAN_HPP_NODISCARD std::vector<SparseImageFormatProperties, SparseImageFormatPropertiesAllocator>
19053 getSparseImageFormatProperties( Format format,
19054 ImageType type,
19055 SampleCountFlagBits samples,
19056 ImageUsageFlags usage,
19057 ImageTiling tiling,
19058 SparseImageFormatPropertiesAllocator & sparseImageFormatPropertiesAllocator,
19059 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
19060 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
19061
19062 //=== VK_VERSION_1_1 ===
19063
19064 // wrapper function for command vkGetPhysicalDeviceFeatures2, see
19065 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures2.html
19066 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19067 void getFeatures2( PhysicalDeviceFeatures2 * pFeatures, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19068 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
19069 // wrapper function for command vkGetPhysicalDeviceFeatures2, see
19070 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures2.html
19071 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19072 VULKAN_HPP_NODISCARD PhysicalDeviceFeatures2 getFeatures2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19073 // wrapper function for command vkGetPhysicalDeviceFeatures2, see
19074 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures2.html
19075 template <typename X,
19076 typename Y,
19077 typename... Z,
19078 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
19079 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19080 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getFeatures2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19081 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
19082
19083 // wrapper function for command vkGetPhysicalDeviceProperties2, see
19084 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties2.html
19085 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19086 void getProperties2( PhysicalDeviceProperties2 * pProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19087 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
19088 // wrapper function for command vkGetPhysicalDeviceProperties2, see
19089 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties2.html
19090 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19091 VULKAN_HPP_NODISCARD PhysicalDeviceProperties2 getProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19092 // wrapper function for command vkGetPhysicalDeviceProperties2, see
19093 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties2.html
19094 template <typename X,
19095 typename Y,
19096 typename... Z,
19097 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
19098 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19099 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19100 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
19101
19102 // wrapper function for command vkGetPhysicalDeviceFormatProperties2, see
19103 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties2.html
19104 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19105 void getFormatProperties2( Format format,
19106 FormatProperties2 * pFormatProperties,
19107 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19108 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
19109 // wrapper function for command vkGetPhysicalDeviceFormatProperties2, see
19110 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties2.html
19111 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19112 VULKAN_HPP_NODISCARD FormatProperties2 getFormatProperties2( Format format,
19113 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19114 // wrapper function for command vkGetPhysicalDeviceFormatProperties2, see
19115 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties2.html
19116 template <typename X,
19117 typename Y,
19118 typename... Z,
19119 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
19120 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19121 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
19122 getFormatProperties2( Format format, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19123 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
19124
19125 // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2, see
19126 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2.html
19127 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19128 VULKAN_HPP_NODISCARD Result getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 * pImageFormatInfo,
19129 ImageFormatProperties2 * pImageFormatProperties,
19130 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19131 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
19132 // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2, see
19133 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2.html
19134 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19135 VULKAN_HPP_NODISCARD typename ResultValueType<ImageFormatProperties2>::type
19136 getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
19137 // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2, see
19138 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2.html
19139 template <typename X,
19140 typename Y,
19141 typename... Z,
19142 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
19143 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19144 VULKAN_HPP_NODISCARD typename ResultValueType<StructureChain<X, Y, Z...>>::type
19145 getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
19146 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
19147
19148 // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2, see
19149 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2.html
19150 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19151 void getQueueFamilyProperties2( uint32_t * pQueueFamilyPropertyCount,
19152 QueueFamilyProperties2 * pQueueFamilyProperties,
19153 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19154 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
19155 // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2, see
19156 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2.html
19157 template <typename QueueFamilyProperties2Allocator = std::allocator<QueueFamilyProperties2>,
19158 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
19159 typename std::enable_if<std::is_same<typename QueueFamilyProperties2Allocator::value_type, QueueFamilyProperties2>::value, int>::type = 0,
19160 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19161 VULKAN_HPP_NODISCARD std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator>
19162 getQueueFamilyProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
19163 // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2, see
19164 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2.html
19165 template <typename QueueFamilyProperties2Allocator = std::allocator<QueueFamilyProperties2>,
19166 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
19167 typename std::enable_if<std::is_same<typename QueueFamilyProperties2Allocator::value_type, QueueFamilyProperties2>::value, int>::type = 0,
19168 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19169 VULKAN_HPP_NODISCARD std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator>
19170 getQueueFamilyProperties2( QueueFamilyProperties2Allocator & queueFamilyProperties2Allocator,
19171 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
19172 // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2, see
19173 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2.html
19174 template <typename StructureChain,
19175 typename StructureChainAllocator = std::allocator<StructureChain>,
19176 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
19177 typename std::enable_if<std::is_same<typename StructureChainAllocator::value_type, StructureChain>::value, int>::type = 0,
19178 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19179 VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator>
19180 getQueueFamilyProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
19181 // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2, see
19182 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2.html
19183 template <typename StructureChain,
19184 typename StructureChainAllocator = std::allocator<StructureChain>,
19185 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
19186 typename std::enable_if<std::is_same<typename StructureChainAllocator::value_type, StructureChain>::value, int>::type = 0,
19187 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19188 VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator>
19189 getQueueFamilyProperties2( StructureChainAllocator & structureChainAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
19190 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
19191
19192 // wrapper function for command vkGetPhysicalDeviceMemoryProperties2, see
19193 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties2.html
19194 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19195 void getMemoryProperties2( PhysicalDeviceMemoryProperties2 * pMemoryProperties,
19196 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19197 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
19198 // wrapper function for command vkGetPhysicalDeviceMemoryProperties2, see
19199 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties2.html
19200 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19201 VULKAN_HPP_NODISCARD PhysicalDeviceMemoryProperties2
19202 getMemoryProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19203 // wrapper function for command vkGetPhysicalDeviceMemoryProperties2, see
19204 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties2.html
19205 template <typename X,
19206 typename Y,
19207 typename... Z,
19208 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
19209 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19210 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
19211 getMemoryProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19212 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
19213
19214 // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties2, see
19215 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2.html
19216 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19217 void getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,
19218 uint32_t * pPropertyCount,
19219 SparseImageFormatProperties2 * pProperties,
19220 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19221 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
19222 // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties2, see
19223 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2.html
19224 template <
19225 typename SparseImageFormatProperties2Allocator = std::allocator<SparseImageFormatProperties2>,
19226 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
19227 typename std::enable_if<std::is_same<typename SparseImageFormatProperties2Allocator::value_type, SparseImageFormatProperties2>::value, int>::type = 0,
19228 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19229 VULKAN_HPP_NODISCARD std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
19230 getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
19231 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
19232 // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties2, see
19233 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2.html
19234 template <
19235 typename SparseImageFormatProperties2Allocator = std::allocator<SparseImageFormatProperties2>,
19236 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
19237 typename std::enable_if<std::is_same<typename SparseImageFormatProperties2Allocator::value_type, SparseImageFormatProperties2>::value, int>::type = 0,
19238 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19239 VULKAN_HPP_NODISCARD std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
19240 getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
19241 SparseImageFormatProperties2Allocator & sparseImageFormatProperties2Allocator,
19242 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
19243 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
19244
19245 // wrapper function for command vkGetPhysicalDeviceExternalBufferProperties, see
19246 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalBufferProperties.html
19247 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19248 void getExternalBufferProperties( const PhysicalDeviceExternalBufferInfo * pExternalBufferInfo,
19249 ExternalBufferProperties * pExternalBufferProperties,
19250 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19251 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
19252 // wrapper function for command vkGetPhysicalDeviceExternalBufferProperties, see
19253 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalBufferProperties.html
19254 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19255 VULKAN_HPP_NODISCARD ExternalBufferProperties getExternalBufferProperties(
19256 const PhysicalDeviceExternalBufferInfo & externalBufferInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19257 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
19258
19259 // wrapper function for command vkGetPhysicalDeviceExternalFenceProperties, see
19260 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalFenceProperties.html
19261 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19262 void getExternalFenceProperties( const PhysicalDeviceExternalFenceInfo * pExternalFenceInfo,
19263 ExternalFenceProperties * pExternalFenceProperties,
19264 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19265 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
19266 // wrapper function for command vkGetPhysicalDeviceExternalFenceProperties, see
19267 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalFenceProperties.html
19268 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19269 VULKAN_HPP_NODISCARD ExternalFenceProperties getExternalFenceProperties(
19270 const PhysicalDeviceExternalFenceInfo & externalFenceInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19271 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
19272
19273 // wrapper function for command vkGetPhysicalDeviceExternalSemaphoreProperties, see
19274 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalSemaphoreProperties.html
19275 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19276 void getExternalSemaphoreProperties( const PhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,
19277 ExternalSemaphoreProperties * pExternalSemaphoreProperties,
19278 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19279 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
19280 // wrapper function for command vkGetPhysicalDeviceExternalSemaphoreProperties, see
19281 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalSemaphoreProperties.html
19282 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19283 VULKAN_HPP_NODISCARD ExternalSemaphoreProperties
19284 getExternalSemaphoreProperties( const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo,
19285 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19286 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
19287
19288 //=== VK_VERSION_1_3 ===
19289
19290 // wrapper function for command vkGetPhysicalDeviceToolProperties, see
19291 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceToolProperties.html
19292 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19293 VULKAN_HPP_NODISCARD Result getToolProperties( uint32_t * pToolCount,
19294 PhysicalDeviceToolProperties * pToolProperties,
19295 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19296 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
19297 // wrapper function for command vkGetPhysicalDeviceToolProperties, see
19298 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceToolProperties.html
19299 template <
19300 typename PhysicalDeviceToolPropertiesAllocator = std::allocator<PhysicalDeviceToolProperties>,
19301 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
19302 typename std::enable_if<std::is_same<typename PhysicalDeviceToolPropertiesAllocator::value_type, PhysicalDeviceToolProperties>::value, int>::type = 0,
19303 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19304 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator>>::type
19305 getToolProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
19306 // wrapper function for command vkGetPhysicalDeviceToolProperties, see
19307 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceToolProperties.html
19308 template <
19309 typename PhysicalDeviceToolPropertiesAllocator = std::allocator<PhysicalDeviceToolProperties>,
19310 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
19311 typename std::enable_if<std::is_same<typename PhysicalDeviceToolPropertiesAllocator::value_type, PhysicalDeviceToolProperties>::value, int>::type = 0,
19312 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19313 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator>>::type
19314 getToolProperties( PhysicalDeviceToolPropertiesAllocator & physicalDeviceToolPropertiesAllocator,
19315 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
19316 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
19317
19318 //=== VK_KHR_surface ===
19319
19320 // wrapper function for command vkGetPhysicalDeviceSurfaceSupportKHR, see
19321 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceSupportKHR.html
19322 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19323 VULKAN_HPP_NODISCARD Result getSurfaceSupportKHR( uint32_t queueFamilyIndex,
19324 SurfaceKHR surface,
19325 Bool32 * pSupported,
19326 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19327 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
19328 // wrapper function for command vkGetPhysicalDeviceSurfaceSupportKHR, see
19329 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceSupportKHR.html
19330 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19331 VULKAN_HPP_NODISCARD typename ResultValueType<Bool32>::type
19332 getSurfaceSupportKHR( uint32_t queueFamilyIndex, SurfaceKHR surface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
19333 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
19334
19335 // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilitiesKHR, see
19336 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilitiesKHR.html
19337 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19338 VULKAN_HPP_NODISCARD Result getSurfaceCapabilitiesKHR( SurfaceKHR surface,
19339 SurfaceCapabilitiesKHR * pSurfaceCapabilities,
19340 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19341 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
19342 // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilitiesKHR, see
19343 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilitiesKHR.html
19344 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19345 VULKAN_HPP_NODISCARD typename ResultValueType<SurfaceCapabilitiesKHR>::type
19346 getSurfaceCapabilitiesKHR( SurfaceKHR surface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
19347 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
19348
19349 // wrapper function for command vkGetPhysicalDeviceSurfaceFormatsKHR, see
19350 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormatsKHR.html
19351 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19352 VULKAN_HPP_NODISCARD Result getSurfaceFormatsKHR( SurfaceKHR surface,
19353 uint32_t * pSurfaceFormatCount,
19354 SurfaceFormatKHR * pSurfaceFormats,
19355 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19356 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
19357 // wrapper function for command vkGetPhysicalDeviceSurfaceFormatsKHR, see
19358 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormatsKHR.html
19359 template <typename SurfaceFormatKHRAllocator = std::allocator<SurfaceFormatKHR>,
19360 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
19361 typename std::enable_if<std::is_same<typename SurfaceFormatKHRAllocator::value_type, SurfaceFormatKHR>::value, int>::type = 0,
19362 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19363 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<SurfaceFormatKHR, SurfaceFormatKHRAllocator>>::type
19364 getSurfaceFormatsKHR( SurfaceKHR surface VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
19365 // wrapper function for command vkGetPhysicalDeviceSurfaceFormatsKHR, see
19366 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormatsKHR.html
19367 template <typename SurfaceFormatKHRAllocator = std::allocator<SurfaceFormatKHR>,
19368 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
19369 typename std::enable_if<std::is_same<typename SurfaceFormatKHRAllocator::value_type, SurfaceFormatKHR>::value, int>::type = 0,
19370 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19371 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<SurfaceFormatKHR, SurfaceFormatKHRAllocator>>::type getSurfaceFormatsKHR(
19372 SurfaceKHR surface, SurfaceFormatKHRAllocator & surfaceFormatKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
19373 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
19374
19375 // wrapper function for command vkGetPhysicalDeviceSurfacePresentModesKHR, see
19376 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfacePresentModesKHR.html
19377 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19378 VULKAN_HPP_NODISCARD Result getSurfacePresentModesKHR( SurfaceKHR surface,
19379 uint32_t * pPresentModeCount,
19380 PresentModeKHR * pPresentModes,
19381 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19382 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
19383 // wrapper function for command vkGetPhysicalDeviceSurfacePresentModesKHR, see
19384 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfacePresentModesKHR.html
19385 template <typename PresentModeKHRAllocator = std::allocator<PresentModeKHR>,
19386 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
19387 typename std::enable_if<std::is_same<typename PresentModeKHRAllocator::value_type, PresentModeKHR>::value, int>::type = 0,
19388 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19389 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PresentModeKHR, PresentModeKHRAllocator>>::type
19390 getSurfacePresentModesKHR( SurfaceKHR surface VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
19391 // wrapper function for command vkGetPhysicalDeviceSurfacePresentModesKHR, see
19392 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfacePresentModesKHR.html
19393 template <typename PresentModeKHRAllocator = std::allocator<PresentModeKHR>,
19394 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
19395 typename std::enable_if<std::is_same<typename PresentModeKHRAllocator::value_type, PresentModeKHR>::value, int>::type = 0,
19396 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19397 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PresentModeKHR, PresentModeKHRAllocator>>::type getSurfacePresentModesKHR(
19398 SurfaceKHR surface, PresentModeKHRAllocator & presentModeKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
19399 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
19400
19401 //=== VK_KHR_swapchain ===
19402
19403 // wrapper function for command vkGetPhysicalDevicePresentRectanglesKHR, see
19404 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDevicePresentRectanglesKHR.html
19405 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19406 VULKAN_HPP_NODISCARD Result getPresentRectanglesKHR( SurfaceKHR surface,
19407 uint32_t * pRectCount,
19408 Rect2D * pRects,
19409 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19410 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
19411 // wrapper function for command vkGetPhysicalDevicePresentRectanglesKHR, see
19412 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDevicePresentRectanglesKHR.html
19413 template <typename Rect2DAllocator = std::allocator<Rect2D>,
19414 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
19415 typename std::enable_if<std::is_same<typename Rect2DAllocator::value_type, Rect2D>::value, int>::type = 0,
19416 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19417 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<Rect2D, Rect2DAllocator>>::type
19418 getPresentRectanglesKHR( SurfaceKHR surface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
19419 // wrapper function for command vkGetPhysicalDevicePresentRectanglesKHR, see
19420 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDevicePresentRectanglesKHR.html
19421 template <typename Rect2DAllocator = std::allocator<Rect2D>,
19422 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
19423 typename std::enable_if<std::is_same<typename Rect2DAllocator::value_type, Rect2D>::value, int>::type = 0,
19424 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19425 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<Rect2D, Rect2DAllocator>>::type
19426 getPresentRectanglesKHR( SurfaceKHR surface, Rect2DAllocator & rect2DAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
19427 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
19428
19429 //=== VK_KHR_display ===
19430
19431 // wrapper function for command vkGetPhysicalDeviceDisplayPropertiesKHR, see
19432 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPropertiesKHR.html
19433 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19434 VULKAN_HPP_NODISCARD Result getDisplayPropertiesKHR( uint32_t * pPropertyCount,
19435 DisplayPropertiesKHR * pProperties,
19436 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19437 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
19438 // wrapper function for command vkGetPhysicalDeviceDisplayPropertiesKHR, see
19439 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPropertiesKHR.html
19440 template <typename DisplayPropertiesKHRAllocator = std::allocator<DisplayPropertiesKHR>,
19441 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
19442 typename std::enable_if<std::is_same<typename DisplayPropertiesKHRAllocator::value_type, DisplayPropertiesKHR>::value, int>::type = 0,
19443 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19444 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DisplayPropertiesKHR, DisplayPropertiesKHRAllocator>>::type
19445 getDisplayPropertiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
19446 // wrapper function for command vkGetPhysicalDeviceDisplayPropertiesKHR, see
19447 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPropertiesKHR.html
19448 template <typename DisplayPropertiesKHRAllocator = std::allocator<DisplayPropertiesKHR>,
19449 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
19450 typename std::enable_if<std::is_same<typename DisplayPropertiesKHRAllocator::value_type, DisplayPropertiesKHR>::value, int>::type = 0,
19451 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19452 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DisplayPropertiesKHR, DisplayPropertiesKHRAllocator>>::type
19453 getDisplayPropertiesKHR( DisplayPropertiesKHRAllocator & displayPropertiesKHRAllocator,
19454 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
19455 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
19456
19457 // wrapper function for command vkGetPhysicalDeviceDisplayPlanePropertiesKHR, see
19458 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPlanePropertiesKHR.html
19459 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19460 VULKAN_HPP_NODISCARD Result getDisplayPlanePropertiesKHR( uint32_t * pPropertyCount,
19461 DisplayPlanePropertiesKHR * pProperties,
19462 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19463 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
19464 // wrapper function for command vkGetPhysicalDeviceDisplayPlanePropertiesKHR, see
19465 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPlanePropertiesKHR.html
19466 template <typename DisplayPlanePropertiesKHRAllocator = std::allocator<DisplayPlanePropertiesKHR>,
19467 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
19468 typename std::enable_if<std::is_same<typename DisplayPlanePropertiesKHRAllocator::value_type, DisplayPlanePropertiesKHR>::value, int>::type = 0,
19469 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19470 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DisplayPlanePropertiesKHR, DisplayPlanePropertiesKHRAllocator>>::type
19471 getDisplayPlanePropertiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
19472 // wrapper function for command vkGetPhysicalDeviceDisplayPlanePropertiesKHR, see
19473 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPlanePropertiesKHR.html
19474 template <typename DisplayPlanePropertiesKHRAllocator = std::allocator<DisplayPlanePropertiesKHR>,
19475 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
19476 typename std::enable_if<std::is_same<typename DisplayPlanePropertiesKHRAllocator::value_type, DisplayPlanePropertiesKHR>::value, int>::type = 0,
19477 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19478 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DisplayPlanePropertiesKHR, DisplayPlanePropertiesKHRAllocator>>::type
19479 getDisplayPlanePropertiesKHR( DisplayPlanePropertiesKHRAllocator & displayPlanePropertiesKHRAllocator,
19480 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
19481 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
19482
19483 // wrapper function for command vkGetDisplayPlaneSupportedDisplaysKHR, see
19484 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneSupportedDisplaysKHR.html
19485 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19486 VULKAN_HPP_NODISCARD Result getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex,
19487 uint32_t * pDisplayCount,
19488 DisplayKHR * pDisplays,
19489 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19490 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
19491 // wrapper function for command vkGetDisplayPlaneSupportedDisplaysKHR, see
19492 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneSupportedDisplaysKHR.html
19493 template <typename DisplayKHRAllocator = std::allocator<DisplayKHR>,
19494 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
19495 typename std::enable_if<std::is_same<typename DisplayKHRAllocator::value_type, DisplayKHR>::value, int>::type = 0,
19496 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19497 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DisplayKHR, DisplayKHRAllocator>>::type
19498 getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
19499 // wrapper function for command vkGetDisplayPlaneSupportedDisplaysKHR, see
19500 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneSupportedDisplaysKHR.html
19501 template <typename DisplayKHRAllocator = std::allocator<DisplayKHR>,
19502 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
19503 typename std::enable_if<std::is_same<typename DisplayKHRAllocator::value_type, DisplayKHR>::value, int>::type = 0,
19504 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19505 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DisplayKHR, DisplayKHRAllocator>>::type getDisplayPlaneSupportedDisplaysKHR(
19506 uint32_t planeIndex, DisplayKHRAllocator & displayKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
19507 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
19508
19509 // wrapper function for command vkGetDisplayModePropertiesKHR, see
19510 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModePropertiesKHR.html
19511 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19512 VULKAN_HPP_NODISCARD Result getDisplayModePropertiesKHR( DisplayKHR display,
19513 uint32_t * pPropertyCount,
19514 DisplayModePropertiesKHR * pProperties,
19515 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19516 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
19517 // wrapper function for command vkGetDisplayModePropertiesKHR, see
19518 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModePropertiesKHR.html
19519 template <typename DisplayModePropertiesKHRAllocator = std::allocator<DisplayModePropertiesKHR>,
19520 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
19521 typename std::enable_if<std::is_same<typename DisplayModePropertiesKHRAllocator::value_type, DisplayModePropertiesKHR>::value, int>::type = 0,
19522 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19523 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DisplayModePropertiesKHR, DisplayModePropertiesKHRAllocator>>::type
19524 getDisplayModePropertiesKHR( DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
19525 // wrapper function for command vkGetDisplayModePropertiesKHR, see
19526 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModePropertiesKHR.html
19527 template <typename DisplayModePropertiesKHRAllocator = std::allocator<DisplayModePropertiesKHR>,
19528 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
19529 typename std::enable_if<std::is_same<typename DisplayModePropertiesKHRAllocator::value_type, DisplayModePropertiesKHR>::value, int>::type = 0,
19530 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19531 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DisplayModePropertiesKHR, DisplayModePropertiesKHRAllocator>>::type
19532 getDisplayModePropertiesKHR( DisplayKHR display,
19533 DisplayModePropertiesKHRAllocator & displayModePropertiesKHRAllocator,
19534 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
19535 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
19536
19537 // wrapper function for command vkCreateDisplayModeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDisplayModeKHR.html
19538 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19539 VULKAN_HPP_NODISCARD Result createDisplayModeKHR( DisplayKHR display,
19540 const DisplayModeCreateInfoKHR * pCreateInfo,
19541 const AllocationCallbacks * pAllocator,
19542 DisplayModeKHR * pMode,
19543 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19544 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
19545 // wrapper function for command vkCreateDisplayModeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDisplayModeKHR.html
19546 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19547 VULKAN_HPP_NODISCARD typename ResultValueType<DisplayModeKHR>::type
19548 createDisplayModeKHR( DisplayKHR display,
19549 const DisplayModeCreateInfoKHR & createInfo,
19550 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
19551 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
19552 # ifndef VULKAN_HPP_NO_SMART_HANDLE
19553 // wrapper function for command vkCreateDisplayModeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDisplayModeKHR.html
19554 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19555 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<DisplayModeKHR, Dispatch>>::type
19556 createDisplayModeKHRUnique( DisplayKHR display,
19557 const DisplayModeCreateInfoKHR & createInfo,
19558 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
19559 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
19560 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
19561 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
19562
19563 // wrapper function for command vkGetDisplayPlaneCapabilitiesKHR, see
19564 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneCapabilitiesKHR.html
19565 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19566 VULKAN_HPP_NODISCARD Result getDisplayPlaneCapabilitiesKHR( DisplayModeKHR mode,
19567 uint32_t planeIndex,
19568 DisplayPlaneCapabilitiesKHR * pCapabilities,
19569 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19570 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
19571 // wrapper function for command vkGetDisplayPlaneCapabilitiesKHR, see
19572 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneCapabilitiesKHR.html
19573 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19574 VULKAN_HPP_NODISCARD typename ResultValueType<DisplayPlaneCapabilitiesKHR>::type
19575 getDisplayPlaneCapabilitiesKHR( DisplayModeKHR mode, uint32_t planeIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
19576 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
19577
19578 #if defined( VK_USE_PLATFORM_XLIB_KHR )
19579 //=== VK_KHR_xlib_surface ===
19580
19581 // wrapper function for command vkGetPhysicalDeviceXlibPresentationSupportKHR, see
19582 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceXlibPresentationSupportKHR.html
19583 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19584 Bool32 getXlibPresentationSupportKHR( uint32_t queueFamilyIndex,
19585 Display * dpy,
19586 VisualID visualID,
19587 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19588 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
19589 // wrapper function for command vkGetPhysicalDeviceXlibPresentationSupportKHR, see
19590 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceXlibPresentationSupportKHR.html
19591 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19592 Bool32 getXlibPresentationSupportKHR( uint32_t queueFamilyIndex,
19593 Display & dpy,
19594 VisualID visualID,
19595 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19596 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
19597 #endif /*VK_USE_PLATFORM_XLIB_KHR*/
19598
19599 #if defined( VK_USE_PLATFORM_XCB_KHR )
19600 //=== VK_KHR_xcb_surface ===
19601
19602 // wrapper function for command vkGetPhysicalDeviceXcbPresentationSupportKHR, see
19603 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceXcbPresentationSupportKHR.html
19604 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19605 Bool32 getXcbPresentationSupportKHR( uint32_t queueFamilyIndex,
19606 xcb_connection_t * connection,
19607 xcb_visualid_t visual_id,
19608 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19609 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
19610 // wrapper function for command vkGetPhysicalDeviceXcbPresentationSupportKHR, see
19611 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceXcbPresentationSupportKHR.html
19612 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19613 Bool32 getXcbPresentationSupportKHR( uint32_t queueFamilyIndex,
19614 xcb_connection_t & connection,
19615 xcb_visualid_t visual_id,
19616 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19617 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
19618 #endif /*VK_USE_PLATFORM_XCB_KHR*/
19619
19620 #if defined( VK_USE_PLATFORM_WAYLAND_KHR )
19621 //=== VK_KHR_wayland_surface ===
19622
19623 // wrapper function for command vkGetPhysicalDeviceWaylandPresentationSupportKHR, see
19624 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceWaylandPresentationSupportKHR.html
19625 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19626 Bool32 getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex,
19627 struct wl_display * display,
19628 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19629 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
19630 // wrapper function for command vkGetPhysicalDeviceWaylandPresentationSupportKHR, see
19631 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceWaylandPresentationSupportKHR.html
19632 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19633 Bool32 getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex,
19634 struct wl_display & display,
19635 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19636 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
19637 #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
19638
19639 #if defined( VK_USE_PLATFORM_WIN32_KHR )
19640 //=== VK_KHR_win32_surface ===
19641
19642 // wrapper function for command vkGetPhysicalDeviceWin32PresentationSupportKHR, see
19643 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceWin32PresentationSupportKHR.html
19644 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19645 Bool32 getWin32PresentationSupportKHR( uint32_t queueFamilyIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19646 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
19647
19648 //=== VK_KHR_video_queue ===
19649
19650 // wrapper function for command vkGetPhysicalDeviceVideoCapabilitiesKHR, see
19651 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoCapabilitiesKHR.html
19652 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19653 VULKAN_HPP_NODISCARD Result getVideoCapabilitiesKHR( const VideoProfileInfoKHR * pVideoProfile,
19654 VideoCapabilitiesKHR * pCapabilities,
19655 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19656 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
19657 // wrapper function for command vkGetPhysicalDeviceVideoCapabilitiesKHR, see
19658 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoCapabilitiesKHR.html
19659 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19660 VULKAN_HPP_NODISCARD typename ResultValueType<VideoCapabilitiesKHR>::type
19661 getVideoCapabilitiesKHR( const VideoProfileInfoKHR & videoProfile, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
19662 // wrapper function for command vkGetPhysicalDeviceVideoCapabilitiesKHR, see
19663 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoCapabilitiesKHR.html
19664 template <typename X,
19665 typename Y,
19666 typename... Z,
19667 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
19668 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19669 VULKAN_HPP_NODISCARD typename ResultValueType<StructureChain<X, Y, Z...>>::type
19670 getVideoCapabilitiesKHR( const VideoProfileInfoKHR & videoProfile, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
19671 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
19672
19673 // wrapper function for command vkGetPhysicalDeviceVideoFormatPropertiesKHR, see
19674 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoFormatPropertiesKHR.html
19675 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19676 VULKAN_HPP_NODISCARD Result getVideoFormatPropertiesKHR( const PhysicalDeviceVideoFormatInfoKHR * pVideoFormatInfo,
19677 uint32_t * pVideoFormatPropertyCount,
19678 VideoFormatPropertiesKHR * pVideoFormatProperties,
19679 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19680 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
19681 // wrapper function for command vkGetPhysicalDeviceVideoFormatPropertiesKHR, see
19682 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoFormatPropertiesKHR.html
19683 template <typename VideoFormatPropertiesKHRAllocator = std::allocator<VideoFormatPropertiesKHR>,
19684 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
19685 typename std::enable_if<std::is_same<typename VideoFormatPropertiesKHRAllocator::value_type, VideoFormatPropertiesKHR>::value, int>::type = 0,
19686 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19687 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VideoFormatPropertiesKHR, VideoFormatPropertiesKHRAllocator>>::type
19688 getVideoFormatPropertiesKHR( const PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo,
19689 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
19690 // wrapper function for command vkGetPhysicalDeviceVideoFormatPropertiesKHR, see
19691 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoFormatPropertiesKHR.html
19692 template <typename VideoFormatPropertiesKHRAllocator = std::allocator<VideoFormatPropertiesKHR>,
19693 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
19694 typename std::enable_if<std::is_same<typename VideoFormatPropertiesKHRAllocator::value_type, VideoFormatPropertiesKHR>::value, int>::type = 0,
19695 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19696 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VideoFormatPropertiesKHR, VideoFormatPropertiesKHRAllocator>>::type
19697 getVideoFormatPropertiesKHR( const PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo,
19698 VideoFormatPropertiesKHRAllocator & videoFormatPropertiesKHRAllocator,
19699 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
19700 // wrapper function for command vkGetPhysicalDeviceVideoFormatPropertiesKHR, see
19701 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoFormatPropertiesKHR.html
19702 template <typename StructureChain,
19703 typename StructureChainAllocator = std::allocator<StructureChain>,
19704 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
19705 typename std::enable_if<std::is_same<typename StructureChainAllocator::value_type, StructureChain>::value, int>::type = 0,
19706 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19707 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<StructureChain, StructureChainAllocator>>::type
19708 getVideoFormatPropertiesKHR( const PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo,
19709 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
19710 // wrapper function for command vkGetPhysicalDeviceVideoFormatPropertiesKHR, see
19711 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoFormatPropertiesKHR.html
19712 template <typename StructureChain,
19713 typename StructureChainAllocator = std::allocator<StructureChain>,
19714 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
19715 typename std::enable_if<std::is_same<typename StructureChainAllocator::value_type, StructureChain>::value, int>::type = 0,
19716 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19717 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<StructureChain, StructureChainAllocator>>::type
19718 getVideoFormatPropertiesKHR( const PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo,
19719 StructureChainAllocator & structureChainAllocator,
19720 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
19721 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
19722
19723 //=== VK_NV_external_memory_capabilities ===
19724
19725 // wrapper function for command vkGetPhysicalDeviceExternalImageFormatPropertiesNV, see
19726 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalImageFormatPropertiesNV.html
19727 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19728 VULKAN_HPP_NODISCARD Result getExternalImageFormatPropertiesNV( Format format,
19729 ImageType type,
19730 ImageTiling tiling,
19731 ImageUsageFlags usage,
19732 ImageCreateFlags flags,
19733 ExternalMemoryHandleTypeFlagsNV externalHandleType,
19734 ExternalImageFormatPropertiesNV * pExternalImageFormatProperties,
19735 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19736 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
19737 // wrapper function for command vkGetPhysicalDeviceExternalImageFormatPropertiesNV, see
19738 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalImageFormatPropertiesNV.html
19739 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19740 VULKAN_HPP_NODISCARD typename ResultValueType<ExternalImageFormatPropertiesNV>::type
19741 getExternalImageFormatPropertiesNV( Format format,
19742 ImageType type,
19743 ImageTiling tiling,
19744 ImageUsageFlags usage,
19745 ImageCreateFlags flags VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
19746 ExternalMemoryHandleTypeFlagsNV externalHandleType VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
19747 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
19748 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
19749
19750 //=== VK_KHR_get_physical_device_properties2 ===
19751
19752 // wrapper function for command vkGetPhysicalDeviceFeatures2KHR, see
19753 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures2KHR.html
19754 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19755 void getFeatures2KHR( PhysicalDeviceFeatures2 * pFeatures, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19756 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
19757 // wrapper function for command vkGetPhysicalDeviceFeatures2KHR, see
19758 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures2KHR.html
19759 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19760 VULKAN_HPP_NODISCARD PhysicalDeviceFeatures2 getFeatures2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19761 // wrapper function for command vkGetPhysicalDeviceFeatures2KHR, see
19762 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures2KHR.html
19763 template <typename X,
19764 typename Y,
19765 typename... Z,
19766 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
19767 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19768 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getFeatures2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19769 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
19770
19771 // wrapper function for command vkGetPhysicalDeviceProperties2KHR, see
19772 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties2KHR.html
19773 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19774 void getProperties2KHR( PhysicalDeviceProperties2 * pProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19775 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
19776 // wrapper function for command vkGetPhysicalDeviceProperties2KHR, see
19777 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties2KHR.html
19778 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19779 VULKAN_HPP_NODISCARD PhysicalDeviceProperties2 getProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19780 // wrapper function for command vkGetPhysicalDeviceProperties2KHR, see
19781 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties2KHR.html
19782 template <typename X,
19783 typename Y,
19784 typename... Z,
19785 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
19786 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19787 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19788 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
19789
19790 // wrapper function for command vkGetPhysicalDeviceFormatProperties2KHR, see
19791 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties2KHR.html
19792 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19793 void getFormatProperties2KHR( Format format,
19794 FormatProperties2 * pFormatProperties,
19795 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19796 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
19797 // wrapper function for command vkGetPhysicalDeviceFormatProperties2KHR, see
19798 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties2KHR.html
19799 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19800 VULKAN_HPP_NODISCARD FormatProperties2 getFormatProperties2KHR( Format format,
19801 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19802 // wrapper function for command vkGetPhysicalDeviceFormatProperties2KHR, see
19803 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties2KHR.html
19804 template <typename X,
19805 typename Y,
19806 typename... Z,
19807 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
19808 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19809 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
19810 getFormatProperties2KHR( Format format, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19811 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
19812
19813 // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2KHR, see
19814 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2KHR.html
19815 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19816 VULKAN_HPP_NODISCARD Result getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 * pImageFormatInfo,
19817 ImageFormatProperties2 * pImageFormatProperties,
19818 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19819 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
19820 // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2KHR, see
19821 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2KHR.html
19822 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19823 VULKAN_HPP_NODISCARD typename ResultValueType<ImageFormatProperties2>::type
19824 getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
19825 // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2KHR, see
19826 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2KHR.html
19827 template <typename X,
19828 typename Y,
19829 typename... Z,
19830 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
19831 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19832 VULKAN_HPP_NODISCARD typename ResultValueType<StructureChain<X, Y, Z...>>::type
19833 getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
19834 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
19835
19836 // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2KHR, see
19837 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2KHR.html
19838 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19839 void getQueueFamilyProperties2KHR( uint32_t * pQueueFamilyPropertyCount,
19840 QueueFamilyProperties2 * pQueueFamilyProperties,
19841 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19842 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
19843 // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2KHR, see
19844 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2KHR.html
19845 template <typename QueueFamilyProperties2Allocator = std::allocator<QueueFamilyProperties2>,
19846 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
19847 typename std::enable_if<std::is_same<typename QueueFamilyProperties2Allocator::value_type, QueueFamilyProperties2>::value, int>::type = 0,
19848 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19849 VULKAN_HPP_NODISCARD std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator>
19850 getQueueFamilyProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
19851 // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2KHR, see
19852 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2KHR.html
19853 template <typename QueueFamilyProperties2Allocator = std::allocator<QueueFamilyProperties2>,
19854 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
19855 typename std::enable_if<std::is_same<typename QueueFamilyProperties2Allocator::value_type, QueueFamilyProperties2>::value, int>::type = 0,
19856 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19857 VULKAN_HPP_NODISCARD std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator>
19858 getQueueFamilyProperties2KHR( QueueFamilyProperties2Allocator & queueFamilyProperties2Allocator,
19859 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
19860 // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2KHR, see
19861 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2KHR.html
19862 template <typename StructureChain,
19863 typename StructureChainAllocator = std::allocator<StructureChain>,
19864 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
19865 typename std::enable_if<std::is_same<typename StructureChainAllocator::value_type, StructureChain>::value, int>::type = 0,
19866 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19867 VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator>
19868 getQueueFamilyProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
19869 // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2KHR, see
19870 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2KHR.html
19871 template <typename StructureChain,
19872 typename StructureChainAllocator = std::allocator<StructureChain>,
19873 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
19874 typename std::enable_if<std::is_same<typename StructureChainAllocator::value_type, StructureChain>::value, int>::type = 0,
19875 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19876 VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator>
19877 getQueueFamilyProperties2KHR( StructureChainAllocator & structureChainAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
19878 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
19879
19880 // wrapper function for command vkGetPhysicalDeviceMemoryProperties2KHR, see
19881 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties2KHR.html
19882 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19883 void getMemoryProperties2KHR( PhysicalDeviceMemoryProperties2 * pMemoryProperties,
19884 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19885 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
19886 // wrapper function for command vkGetPhysicalDeviceMemoryProperties2KHR, see
19887 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties2KHR.html
19888 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19889 VULKAN_HPP_NODISCARD PhysicalDeviceMemoryProperties2
19890 getMemoryProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19891 // wrapper function for command vkGetPhysicalDeviceMemoryProperties2KHR, see
19892 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties2KHR.html
19893 template <typename X,
19894 typename Y,
19895 typename... Z,
19896 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
19897 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19898 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
19899 getMemoryProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19900 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
19901
19902 // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties2KHR, see
19903 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2KHR.html
19904 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19905 void getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,
19906 uint32_t * pPropertyCount,
19907 SparseImageFormatProperties2 * pProperties,
19908 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19909 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
19910 // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties2KHR, see
19911 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2KHR.html
19912 template <
19913 typename SparseImageFormatProperties2Allocator = std::allocator<SparseImageFormatProperties2>,
19914 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
19915 typename std::enable_if<std::is_same<typename SparseImageFormatProperties2Allocator::value_type, SparseImageFormatProperties2>::value, int>::type = 0,
19916 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19917 VULKAN_HPP_NODISCARD std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
19918 getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
19919 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
19920 // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties2KHR, see
19921 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2KHR.html
19922 template <
19923 typename SparseImageFormatProperties2Allocator = std::allocator<SparseImageFormatProperties2>,
19924 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
19925 typename std::enable_if<std::is_same<typename SparseImageFormatProperties2Allocator::value_type, SparseImageFormatProperties2>::value, int>::type = 0,
19926 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19927 VULKAN_HPP_NODISCARD std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
19928 getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
19929 SparseImageFormatProperties2Allocator & sparseImageFormatProperties2Allocator,
19930 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
19931 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
19932
19933 //=== VK_KHR_external_memory_capabilities ===
19934
19935 // wrapper function for command vkGetPhysicalDeviceExternalBufferPropertiesKHR, see
19936 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalBufferPropertiesKHR.html
19937 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19938 void getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfo * pExternalBufferInfo,
19939 ExternalBufferProperties * pExternalBufferProperties,
19940 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19941 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
19942 // wrapper function for command vkGetPhysicalDeviceExternalBufferPropertiesKHR, see
19943 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalBufferPropertiesKHR.html
19944 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19945 VULKAN_HPP_NODISCARD ExternalBufferProperties getExternalBufferPropertiesKHR(
19946 const PhysicalDeviceExternalBufferInfo & externalBufferInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19947 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
19948
19949 //=== VK_KHR_external_semaphore_capabilities ===
19950
19951 // wrapper function for command vkGetPhysicalDeviceExternalSemaphorePropertiesKHR, see
19952 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalSemaphorePropertiesKHR.html
19953 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19954 void getExternalSemaphorePropertiesKHR( const PhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,
19955 ExternalSemaphoreProperties * pExternalSemaphoreProperties,
19956 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19957 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
19958 // wrapper function for command vkGetPhysicalDeviceExternalSemaphorePropertiesKHR, see
19959 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalSemaphorePropertiesKHR.html
19960 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19961 VULKAN_HPP_NODISCARD ExternalSemaphoreProperties
19962 getExternalSemaphorePropertiesKHR( const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo,
19963 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19964 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
19965
19966 //=== VK_EXT_direct_mode_display ===
19967
19968 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
19969 // wrapper function for command vkReleaseDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseDisplayEXT.html
19970 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19971 VULKAN_HPP_NODISCARD Result releaseDisplayEXT( DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19972 #else
19973 // wrapper function for command vkReleaseDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseDisplayEXT.html
19974 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19975 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
19976 releaseDisplayEXT( DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
19977 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
19978
19979 #if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT )
19980 //=== VK_EXT_acquire_xlib_display ===
19981
19982 // wrapper function for command vkAcquireXlibDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireXlibDisplayEXT.html
19983 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19984 VULKAN_HPP_NODISCARD Result acquireXlibDisplayEXT( Display * dpy,
19985 DisplayKHR display,
19986 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
19987 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
19988 // wrapper function for command vkAcquireXlibDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireXlibDisplayEXT.html
19989 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19990 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
19991 acquireXlibDisplayEXT( Display & dpy, DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
19992 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
19993
19994 // wrapper function for command vkGetRandROutputDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRandROutputDisplayEXT.html
19995 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
19996 VULKAN_HPP_NODISCARD Result getRandROutputDisplayEXT( Display * dpy,
19997 RROutput rrOutput,
19998 DisplayKHR * pDisplay,
19999 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
20000 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
20001 // wrapper function for command vkGetRandROutputDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRandROutputDisplayEXT.html
20002 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20003 VULKAN_HPP_NODISCARD typename ResultValueType<DisplayKHR>::type
20004 getRandROutputDisplayEXT( Display & dpy, RROutput rrOutput, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
20005 # ifndef VULKAN_HPP_NO_SMART_HANDLE
20006 // wrapper function for command vkGetRandROutputDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRandROutputDisplayEXT.html
20007 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20008 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<DisplayKHR, Dispatch>>::type
20009 getRandROutputDisplayEXTUnique( Display & dpy, RROutput rrOutput, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
20010 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
20011 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
20012 #endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
20013
20014 //=== VK_EXT_display_surface_counter ===
20015
20016 // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilities2EXT, see
20017 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilities2EXT.html
20018 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20019 VULKAN_HPP_NODISCARD Result getSurfaceCapabilities2EXT( SurfaceKHR surface,
20020 SurfaceCapabilities2EXT * pSurfaceCapabilities,
20021 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
20022 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
20023 // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilities2EXT, see
20024 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilities2EXT.html
20025 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20026 VULKAN_HPP_NODISCARD typename ResultValueType<SurfaceCapabilities2EXT>::type
20027 getSurfaceCapabilities2EXT( SurfaceKHR surface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
20028 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
20029
20030 //=== VK_KHR_external_fence_capabilities ===
20031
20032 // wrapper function for command vkGetPhysicalDeviceExternalFencePropertiesKHR, see
20033 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalFencePropertiesKHR.html
20034 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20035 void getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfo * pExternalFenceInfo,
20036 ExternalFenceProperties * pExternalFenceProperties,
20037 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
20038 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
20039 // wrapper function for command vkGetPhysicalDeviceExternalFencePropertiesKHR, see
20040 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalFencePropertiesKHR.html
20041 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20042 VULKAN_HPP_NODISCARD ExternalFenceProperties getExternalFencePropertiesKHR(
20043 const PhysicalDeviceExternalFenceInfo & externalFenceInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
20044 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
20045
20046 //=== VK_KHR_performance_query ===
20047
20048 // wrapper function for command vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR, see
20049 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR.html
20050 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20051 VULKAN_HPP_NODISCARD Result
20052 enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex,
20053 uint32_t * pCounterCount,
20054 PerformanceCounterKHR * pCounters,
20055 PerformanceCounterDescriptionKHR * pCounterDescriptions,
20056 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
20057 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
20058 // wrapper function for command vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR, see
20059 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR.html
20060 template <typename PerformanceCounterKHRAllocator = std::allocator<PerformanceCounterKHR>,
20061 typename PerformanceCounterDescriptionKHRAllocator = std::allocator<PerformanceCounterDescriptionKHR>,
20062 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
20063 typename std::enable_if<std::is_same<typename PerformanceCounterKHRAllocator::value_type, PerformanceCounterKHR>::value &&
20064 std::is_same<typename PerformanceCounterDescriptionKHRAllocator::value_type, PerformanceCounterDescriptionKHR>::value,
20065 int>::type = 0,
20066 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20067 VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<std::vector<PerformanceCounterKHR, PerformanceCounterKHRAllocator>,
20068 std::vector<PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator>>>::type
20069 enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
20070 // wrapper function for command vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR, see
20071 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR.html
20072 template <typename PerformanceCounterKHRAllocator = std::allocator<PerformanceCounterKHR>,
20073 typename PerformanceCounterDescriptionKHRAllocator = std::allocator<PerformanceCounterDescriptionKHR>,
20074 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
20075 typename std::enable_if<std::is_same<typename PerformanceCounterKHRAllocator::value_type, PerformanceCounterKHR>::value &&
20076 std::is_same<typename PerformanceCounterDescriptionKHRAllocator::value_type, PerformanceCounterDescriptionKHR>::value,
20077 int>::type = 0,
20078 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20079 VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<std::vector<PerformanceCounterKHR, PerformanceCounterKHRAllocator>,
20080 std::vector<PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator>>>::type
20081 enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex,
20082 PerformanceCounterKHRAllocator & performanceCounterKHRAllocator,
20083 PerformanceCounterDescriptionKHRAllocator & performanceCounterDescriptionKHRAllocator,
20084 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
20085 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
20086
20087 // wrapper function for command vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR, see
20088 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR.html
20089 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20090 void getQueueFamilyPerformanceQueryPassesKHR( const QueryPoolPerformanceCreateInfoKHR * pPerformanceQueryCreateInfo,
20091 uint32_t * pNumPasses,
20092 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
20093 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
20094 // wrapper function for command vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR, see
20095 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR.html
20096 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20097 VULKAN_HPP_NODISCARD uint32_t
20098 getQueueFamilyPerformanceQueryPassesKHR( const QueryPoolPerformanceCreateInfoKHR & performanceQueryCreateInfo,
20099 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
20100 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
20101
20102 //=== VK_KHR_get_surface_capabilities2 ===
20103
20104 // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilities2KHR, see
20105 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilities2KHR.html
20106 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20107 VULKAN_HPP_NODISCARD Result getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
20108 SurfaceCapabilities2KHR * pSurfaceCapabilities,
20109 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
20110 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
20111 // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilities2KHR, see
20112 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilities2KHR.html
20113 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20114 VULKAN_HPP_NODISCARD typename ResultValueType<SurfaceCapabilities2KHR>::type
20115 getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
20116 // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilities2KHR, see
20117 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilities2KHR.html
20118 template <typename X,
20119 typename Y,
20120 typename... Z,
20121 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
20122 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20123 VULKAN_HPP_NODISCARD typename ResultValueType<StructureChain<X, Y, Z...>>::type
20124 getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
20125 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
20126
20127 // wrapper function for command vkGetPhysicalDeviceSurfaceFormats2KHR, see
20128 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormats2KHR.html
20129 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20130 VULKAN_HPP_NODISCARD Result getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
20131 uint32_t * pSurfaceFormatCount,
20132 SurfaceFormat2KHR * pSurfaceFormats,
20133 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
20134 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
20135 // wrapper function for command vkGetPhysicalDeviceSurfaceFormats2KHR, see
20136 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormats2KHR.html
20137 template <typename SurfaceFormat2KHRAllocator = std::allocator<SurfaceFormat2KHR>,
20138 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
20139 typename std::enable_if<std::is_same<typename SurfaceFormat2KHRAllocator::value_type, SurfaceFormat2KHR>::value, int>::type = 0,
20140 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20141 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<SurfaceFormat2KHR, SurfaceFormat2KHRAllocator>>::type
20142 getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
20143 // wrapper function for command vkGetPhysicalDeviceSurfaceFormats2KHR, see
20144 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormats2KHR.html
20145 template <typename SurfaceFormat2KHRAllocator = std::allocator<SurfaceFormat2KHR>,
20146 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
20147 typename std::enable_if<std::is_same<typename SurfaceFormat2KHRAllocator::value_type, SurfaceFormat2KHR>::value, int>::type = 0,
20148 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20149 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<SurfaceFormat2KHR, SurfaceFormat2KHRAllocator>>::type
20150 getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
20151 SurfaceFormat2KHRAllocator & surfaceFormat2KHRAllocator,
20152 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
20153 // wrapper function for command vkGetPhysicalDeviceSurfaceFormats2KHR, see
20154 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormats2KHR.html
20155 template <typename StructureChain,
20156 typename StructureChainAllocator = std::allocator<StructureChain>,
20157 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
20158 typename std::enable_if<std::is_same<typename StructureChainAllocator::value_type, StructureChain>::value, int>::type = 0,
20159 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20160 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<StructureChain, StructureChainAllocator>>::type
20161 getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
20162 // wrapper function for command vkGetPhysicalDeviceSurfaceFormats2KHR, see
20163 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormats2KHR.html
20164 template <typename StructureChain,
20165 typename StructureChainAllocator = std::allocator<StructureChain>,
20166 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
20167 typename std::enable_if<std::is_same<typename StructureChainAllocator::value_type, StructureChain>::value, int>::type = 0,
20168 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20169 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<StructureChain, StructureChainAllocator>>::type
20170 getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
20171 StructureChainAllocator & structureChainAllocator,
20172 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
20173 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
20174
20175 //=== VK_KHR_get_display_properties2 ===
20176
20177 // wrapper function for command vkGetPhysicalDeviceDisplayProperties2KHR, see
20178 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayProperties2KHR.html
20179 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20180 VULKAN_HPP_NODISCARD Result getDisplayProperties2KHR( uint32_t * pPropertyCount,
20181 DisplayProperties2KHR * pProperties,
20182 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
20183 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
20184 // wrapper function for command vkGetPhysicalDeviceDisplayProperties2KHR, see
20185 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayProperties2KHR.html
20186 template <typename DisplayProperties2KHRAllocator = std::allocator<DisplayProperties2KHR>,
20187 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
20188 typename std::enable_if<std::is_same<typename DisplayProperties2KHRAllocator::value_type, DisplayProperties2KHR>::value, int>::type = 0,
20189 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20190 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DisplayProperties2KHR, DisplayProperties2KHRAllocator>>::type
20191 getDisplayProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
20192 // wrapper function for command vkGetPhysicalDeviceDisplayProperties2KHR, see
20193 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayProperties2KHR.html
20194 template <typename DisplayProperties2KHRAllocator = std::allocator<DisplayProperties2KHR>,
20195 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
20196 typename std::enable_if<std::is_same<typename DisplayProperties2KHRAllocator::value_type, DisplayProperties2KHR>::value, int>::type = 0,
20197 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20198 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DisplayProperties2KHR, DisplayProperties2KHRAllocator>>::type
20199 getDisplayProperties2KHR( DisplayProperties2KHRAllocator & displayProperties2KHRAllocator,
20200 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
20201 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
20202
20203 // wrapper function for command vkGetPhysicalDeviceDisplayPlaneProperties2KHR, see
20204 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPlaneProperties2KHR.html
20205 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20206 VULKAN_HPP_NODISCARD Result getDisplayPlaneProperties2KHR( uint32_t * pPropertyCount,
20207 DisplayPlaneProperties2KHR * pProperties,
20208 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
20209 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
20210 // wrapper function for command vkGetPhysicalDeviceDisplayPlaneProperties2KHR, see
20211 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPlaneProperties2KHR.html
20212 template <typename DisplayPlaneProperties2KHRAllocator = std::allocator<DisplayPlaneProperties2KHR>,
20213 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
20214 typename std::enable_if<std::is_same<typename DisplayPlaneProperties2KHRAllocator::value_type, DisplayPlaneProperties2KHR>::value, int>::type = 0,
20215 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20216 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DisplayPlaneProperties2KHR, DisplayPlaneProperties2KHRAllocator>>::type
20217 getDisplayPlaneProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
20218 // wrapper function for command vkGetPhysicalDeviceDisplayPlaneProperties2KHR, see
20219 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPlaneProperties2KHR.html
20220 template <typename DisplayPlaneProperties2KHRAllocator = std::allocator<DisplayPlaneProperties2KHR>,
20221 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
20222 typename std::enable_if<std::is_same<typename DisplayPlaneProperties2KHRAllocator::value_type, DisplayPlaneProperties2KHR>::value, int>::type = 0,
20223 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20224 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DisplayPlaneProperties2KHR, DisplayPlaneProperties2KHRAllocator>>::type
20225 getDisplayPlaneProperties2KHR( DisplayPlaneProperties2KHRAllocator & displayPlaneProperties2KHRAllocator,
20226 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
20227 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
20228
20229 // wrapper function for command vkGetDisplayModeProperties2KHR, see
20230 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModeProperties2KHR.html
20231 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20232 VULKAN_HPP_NODISCARD Result getDisplayModeProperties2KHR( DisplayKHR display,
20233 uint32_t * pPropertyCount,
20234 DisplayModeProperties2KHR * pProperties,
20235 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
20236 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
20237 // wrapper function for command vkGetDisplayModeProperties2KHR, see
20238 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModeProperties2KHR.html
20239 template <typename DisplayModeProperties2KHRAllocator = std::allocator<DisplayModeProperties2KHR>,
20240 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
20241 typename std::enable_if<std::is_same<typename DisplayModeProperties2KHRAllocator::value_type, DisplayModeProperties2KHR>::value, int>::type = 0,
20242 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20243 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DisplayModeProperties2KHR, DisplayModeProperties2KHRAllocator>>::type
20244 getDisplayModeProperties2KHR( DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
20245 // wrapper function for command vkGetDisplayModeProperties2KHR, see
20246 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModeProperties2KHR.html
20247 template <typename DisplayModeProperties2KHRAllocator = std::allocator<DisplayModeProperties2KHR>,
20248 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
20249 typename std::enable_if<std::is_same<typename DisplayModeProperties2KHRAllocator::value_type, DisplayModeProperties2KHR>::value, int>::type = 0,
20250 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20251 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DisplayModeProperties2KHR, DisplayModeProperties2KHRAllocator>>::type
20252 getDisplayModeProperties2KHR( DisplayKHR display,
20253 DisplayModeProperties2KHRAllocator & displayModeProperties2KHRAllocator,
20254 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
20255 // wrapper function for command vkGetDisplayModeProperties2KHR, see
20256 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModeProperties2KHR.html
20257 template <typename StructureChain,
20258 typename StructureChainAllocator = std::allocator<StructureChain>,
20259 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
20260 typename std::enable_if<std::is_same<typename StructureChainAllocator::value_type, StructureChain>::value, int>::type = 0,
20261 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20262 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<StructureChain, StructureChainAllocator>>::type
20263 getDisplayModeProperties2KHR( DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
20264 // wrapper function for command vkGetDisplayModeProperties2KHR, see
20265 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModeProperties2KHR.html
20266 template <typename StructureChain,
20267 typename StructureChainAllocator = std::allocator<StructureChain>,
20268 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
20269 typename std::enable_if<std::is_same<typename StructureChainAllocator::value_type, StructureChain>::value, int>::type = 0,
20270 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20271 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<StructureChain, StructureChainAllocator>>::type getDisplayModeProperties2KHR(
20272 DisplayKHR display, StructureChainAllocator & structureChainAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
20273 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
20274
20275 // wrapper function for command vkGetDisplayPlaneCapabilities2KHR, see
20276 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneCapabilities2KHR.html
20277 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20278 VULKAN_HPP_NODISCARD Result getDisplayPlaneCapabilities2KHR( const DisplayPlaneInfo2KHR * pDisplayPlaneInfo,
20279 DisplayPlaneCapabilities2KHR * pCapabilities,
20280 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
20281 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
20282 // wrapper function for command vkGetDisplayPlaneCapabilities2KHR, see
20283 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneCapabilities2KHR.html
20284 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20285 VULKAN_HPP_NODISCARD typename ResultValueType<DisplayPlaneCapabilities2KHR>::type
20286 getDisplayPlaneCapabilities2KHR( const DisplayPlaneInfo2KHR & displayPlaneInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
20287 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
20288
20289 //=== VK_EXT_sample_locations ===
20290
20291 // wrapper function for command vkGetPhysicalDeviceMultisamplePropertiesEXT, see
20292 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMultisamplePropertiesEXT.html
20293 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20294 void getMultisamplePropertiesEXT( SampleCountFlagBits samples,
20295 MultisamplePropertiesEXT * pMultisampleProperties,
20296 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
20297 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
20298 // wrapper function for command vkGetPhysicalDeviceMultisamplePropertiesEXT, see
20299 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMultisamplePropertiesEXT.html
20300 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20301 VULKAN_HPP_NODISCARD MultisamplePropertiesEXT
20302 getMultisamplePropertiesEXT( SampleCountFlagBits samples, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
20303 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
20304
20305 //=== VK_EXT_calibrated_timestamps ===
20306
20307 // wrapper function for command vkGetPhysicalDeviceCalibrateableTimeDomainsEXT, see
20308 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCalibrateableTimeDomainsEXT.html
20309 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20310 VULKAN_HPP_NODISCARD Result getCalibrateableTimeDomainsEXT( uint32_t * pTimeDomainCount,
20311 TimeDomainKHR * pTimeDomains,
20312 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
20313 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
20314 // wrapper function for command vkGetPhysicalDeviceCalibrateableTimeDomainsEXT, see
20315 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCalibrateableTimeDomainsEXT.html
20316 template <typename TimeDomainKHRAllocator = std::allocator<TimeDomainKHR>,
20317 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
20318 typename std::enable_if<std::is_same<typename TimeDomainKHRAllocator::value_type, TimeDomainKHR>::value, int>::type = 0,
20319 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20320 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<TimeDomainKHR, TimeDomainKHRAllocator>>::type
20321 getCalibrateableTimeDomainsEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
20322 // wrapper function for command vkGetPhysicalDeviceCalibrateableTimeDomainsEXT, see
20323 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCalibrateableTimeDomainsEXT.html
20324 template <typename TimeDomainKHRAllocator = std::allocator<TimeDomainKHR>,
20325 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
20326 typename std::enable_if<std::is_same<typename TimeDomainKHRAllocator::value_type, TimeDomainKHR>::value, int>::type = 0,
20327 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20328 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<TimeDomainKHR, TimeDomainKHRAllocator>>::type
20329 getCalibrateableTimeDomainsEXT( TimeDomainKHRAllocator & timeDomainKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
20330 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
20331
20332 //=== VK_KHR_fragment_shading_rate ===
20333
20334 // wrapper function for command vkGetPhysicalDeviceFragmentShadingRatesKHR, see
20335 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFragmentShadingRatesKHR.html
20336 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20337 VULKAN_HPP_NODISCARD Result getFragmentShadingRatesKHR( uint32_t * pFragmentShadingRateCount,
20338 PhysicalDeviceFragmentShadingRateKHR * pFragmentShadingRates,
20339 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
20340 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
20341 // wrapper function for command vkGetPhysicalDeviceFragmentShadingRatesKHR, see
20342 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFragmentShadingRatesKHR.html
20343 template <
20344 typename PhysicalDeviceFragmentShadingRateKHRAllocator = std::allocator<PhysicalDeviceFragmentShadingRateKHR>,
20345 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
20346 typename std::enable_if<std::is_same<typename PhysicalDeviceFragmentShadingRateKHRAllocator::value_type, PhysicalDeviceFragmentShadingRateKHR>::value,
20347 int>::type = 0,
20348 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20349 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PhysicalDeviceFragmentShadingRateKHR, PhysicalDeviceFragmentShadingRateKHRAllocator>>::type
20350 getFragmentShadingRatesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
20351 // wrapper function for command vkGetPhysicalDeviceFragmentShadingRatesKHR, see
20352 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFragmentShadingRatesKHR.html
20353 template <
20354 typename PhysicalDeviceFragmentShadingRateKHRAllocator = std::allocator<PhysicalDeviceFragmentShadingRateKHR>,
20355 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
20356 typename std::enable_if<std::is_same<typename PhysicalDeviceFragmentShadingRateKHRAllocator::value_type, PhysicalDeviceFragmentShadingRateKHR>::value,
20357 int>::type = 0,
20358 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20359 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PhysicalDeviceFragmentShadingRateKHR, PhysicalDeviceFragmentShadingRateKHRAllocator>>::type
20360 getFragmentShadingRatesKHR( PhysicalDeviceFragmentShadingRateKHRAllocator & physicalDeviceFragmentShadingRateKHRAllocator,
20361 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
20362 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
20363
20364 //=== VK_EXT_tooling_info ===
20365
20366 // wrapper function for command vkGetPhysicalDeviceToolPropertiesEXT, see
20367 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceToolPropertiesEXT.html
20368 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20369 VULKAN_HPP_NODISCARD Result getToolPropertiesEXT( uint32_t * pToolCount,
20370 PhysicalDeviceToolProperties * pToolProperties,
20371 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
20372 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
20373 // wrapper function for command vkGetPhysicalDeviceToolPropertiesEXT, see
20374 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceToolPropertiesEXT.html
20375 template <
20376 typename PhysicalDeviceToolPropertiesAllocator = std::allocator<PhysicalDeviceToolProperties>,
20377 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
20378 typename std::enable_if<std::is_same<typename PhysicalDeviceToolPropertiesAllocator::value_type, PhysicalDeviceToolProperties>::value, int>::type = 0,
20379 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20380 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator>>::type
20381 getToolPropertiesEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
20382 // wrapper function for command vkGetPhysicalDeviceToolPropertiesEXT, see
20383 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceToolPropertiesEXT.html
20384 template <
20385 typename PhysicalDeviceToolPropertiesAllocator = std::allocator<PhysicalDeviceToolProperties>,
20386 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
20387 typename std::enable_if<std::is_same<typename PhysicalDeviceToolPropertiesAllocator::value_type, PhysicalDeviceToolProperties>::value, int>::type = 0,
20388 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20389 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator>>::type
20390 getToolPropertiesEXT( PhysicalDeviceToolPropertiesAllocator & physicalDeviceToolPropertiesAllocator,
20391 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
20392 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
20393
20394 //=== VK_NV_cooperative_matrix ===
20395
20396 // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixPropertiesNV, see
20397 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixPropertiesNV.html
20398 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20399 VULKAN_HPP_NODISCARD Result getCooperativeMatrixPropertiesNV( uint32_t * pPropertyCount,
20400 CooperativeMatrixPropertiesNV * pProperties,
20401 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
20402 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
20403 // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixPropertiesNV, see
20404 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixPropertiesNV.html
20405 template <
20406 typename CooperativeMatrixPropertiesNVAllocator = std::allocator<CooperativeMatrixPropertiesNV>,
20407 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
20408 typename std::enable_if<std::is_same<typename CooperativeMatrixPropertiesNVAllocator::value_type, CooperativeMatrixPropertiesNV>::value, int>::type = 0,
20409 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20410 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<CooperativeMatrixPropertiesNV, CooperativeMatrixPropertiesNVAllocator>>::type
20411 getCooperativeMatrixPropertiesNV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
20412 // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixPropertiesNV, see
20413 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixPropertiesNV.html
20414 template <
20415 typename CooperativeMatrixPropertiesNVAllocator = std::allocator<CooperativeMatrixPropertiesNV>,
20416 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
20417 typename std::enable_if<std::is_same<typename CooperativeMatrixPropertiesNVAllocator::value_type, CooperativeMatrixPropertiesNV>::value, int>::type = 0,
20418 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20419 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<CooperativeMatrixPropertiesNV, CooperativeMatrixPropertiesNVAllocator>>::type
20420 getCooperativeMatrixPropertiesNV( CooperativeMatrixPropertiesNVAllocator & cooperativeMatrixPropertiesNVAllocator,
20421 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
20422 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
20423
20424 //=== VK_NV_coverage_reduction_mode ===
20425
20426 // wrapper function for command vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV, see
20427 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV.html
20428 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20429 VULKAN_HPP_NODISCARD Result
20430 getSupportedFramebufferMixedSamplesCombinationsNV( uint32_t * pCombinationCount,
20431 FramebufferMixedSamplesCombinationNV * pCombinations,
20432 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
20433 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
20434 // wrapper function for command vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV, see
20435 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV.html
20436 template <
20437 typename FramebufferMixedSamplesCombinationNVAllocator = std::allocator<FramebufferMixedSamplesCombinationNV>,
20438 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
20439 typename std::enable_if<std::is_same<typename FramebufferMixedSamplesCombinationNVAllocator::value_type, FramebufferMixedSamplesCombinationNV>::value,
20440 int>::type = 0,
20441 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20442 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<FramebufferMixedSamplesCombinationNV, FramebufferMixedSamplesCombinationNVAllocator>>::type
20443 getSupportedFramebufferMixedSamplesCombinationsNV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
20444 // wrapper function for command vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV, see
20445 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV.html
20446 template <
20447 typename FramebufferMixedSamplesCombinationNVAllocator = std::allocator<FramebufferMixedSamplesCombinationNV>,
20448 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
20449 typename std::enable_if<std::is_same<typename FramebufferMixedSamplesCombinationNVAllocator::value_type, FramebufferMixedSamplesCombinationNV>::value,
20450 int>::type = 0,
20451 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20452 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<FramebufferMixedSamplesCombinationNV, FramebufferMixedSamplesCombinationNVAllocator>>::type
20453 getSupportedFramebufferMixedSamplesCombinationsNV( FramebufferMixedSamplesCombinationNVAllocator & framebufferMixedSamplesCombinationNVAllocator,
20454 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
20455 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
20456
20457 #if defined( VK_USE_PLATFORM_WIN32_KHR )
20458 //=== VK_EXT_full_screen_exclusive ===
20459
20460 // wrapper function for command vkGetPhysicalDeviceSurfacePresentModes2EXT, see
20461 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfacePresentModes2EXT.html
20462 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20463 VULKAN_HPP_NODISCARD Result getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
20464 uint32_t * pPresentModeCount,
20465 PresentModeKHR * pPresentModes,
20466 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
20467 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
20468 // wrapper function for command vkGetPhysicalDeviceSurfacePresentModes2EXT, see
20469 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfacePresentModes2EXT.html
20470 template <typename PresentModeKHRAllocator = std::allocator<PresentModeKHR>,
20471 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
20472 typename std::enable_if<std::is_same<typename PresentModeKHRAllocator::value_type, PresentModeKHR>::value, int>::type = 0,
20473 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20474 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PresentModeKHR, PresentModeKHRAllocator>>::type
20475 getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
20476 // wrapper function for command vkGetPhysicalDeviceSurfacePresentModes2EXT, see
20477 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfacePresentModes2EXT.html
20478 template <typename PresentModeKHRAllocator = std::allocator<PresentModeKHR>,
20479 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
20480 typename std::enable_if<std::is_same<typename PresentModeKHRAllocator::value_type, PresentModeKHR>::value, int>::type = 0,
20481 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20482 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PresentModeKHR, PresentModeKHRAllocator>>::type
20483 getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
20484 PresentModeKHRAllocator & presentModeKHRAllocator,
20485 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
20486 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
20487 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
20488
20489 //=== VK_EXT_acquire_drm_display ===
20490
20491 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
20492 // wrapper function for command vkAcquireDrmDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireDrmDisplayEXT.html
20493 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20494 VULKAN_HPP_NODISCARD Result acquireDrmDisplayEXT( int32_t drmFd,
20495 DisplayKHR display,
20496 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
20497 #else
20498 // wrapper function for command vkAcquireDrmDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireDrmDisplayEXT.html
20499 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20500 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
20501 acquireDrmDisplayEXT( int32_t drmFd, DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
20502 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
20503
20504 // wrapper function for command vkGetDrmDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDrmDisplayEXT.html
20505 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20506 VULKAN_HPP_NODISCARD Result getDrmDisplayEXT( int32_t drmFd,
20507 uint32_t connectorId,
20508 DisplayKHR * display,
20509 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
20510 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
20511 // wrapper function for command vkGetDrmDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDrmDisplayEXT.html
20512 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20513 VULKAN_HPP_NODISCARD typename ResultValueType<DisplayKHR>::type
20514 getDrmDisplayEXT( int32_t drmFd, uint32_t connectorId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
20515 # ifndef VULKAN_HPP_NO_SMART_HANDLE
20516 // wrapper function for command vkGetDrmDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDrmDisplayEXT.html
20517 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20518 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<DisplayKHR, Dispatch>>::type
20519 getDrmDisplayEXTUnique( int32_t drmFd, uint32_t connectorId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
20520 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
20521 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
20522
20523 //=== VK_KHR_video_encode_queue ===
20524
20525 // wrapper function for command vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR, see
20526 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR.html
20527 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20528 VULKAN_HPP_NODISCARD Result
20529 getVideoEncodeQualityLevelPropertiesKHR( const PhysicalDeviceVideoEncodeQualityLevelInfoKHR * pQualityLevelInfo,
20530 VideoEncodeQualityLevelPropertiesKHR * pQualityLevelProperties,
20531 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
20532 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
20533 // wrapper function for command vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR, see
20534 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR.html
20535 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20536 VULKAN_HPP_NODISCARD typename ResultValueType<VideoEncodeQualityLevelPropertiesKHR>::type
20537 getVideoEncodeQualityLevelPropertiesKHR( const PhysicalDeviceVideoEncodeQualityLevelInfoKHR & qualityLevelInfo,
20538 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
20539 // wrapper function for command vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR, see
20540 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR.html
20541 template <typename X,
20542 typename Y,
20543 typename... Z,
20544 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
20545 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20546 VULKAN_HPP_NODISCARD typename ResultValueType<StructureChain<X, Y, Z...>>::type
20547 getVideoEncodeQualityLevelPropertiesKHR( const PhysicalDeviceVideoEncodeQualityLevelInfoKHR & qualityLevelInfo,
20548 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
20549 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
20550
20551 #if defined( VK_USE_PLATFORM_WIN32_KHR )
20552 //=== VK_NV_acquire_winrt_display ===
20553
20554 # ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
20555 // wrapper function for command vkAcquireWinrtDisplayNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireWinrtDisplayNV.html
20556 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20557 VULKAN_HPP_NODISCARD Result acquireWinrtDisplayNV( DisplayKHR display,
20558 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
20559 # else
20560 // wrapper function for command vkAcquireWinrtDisplayNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireWinrtDisplayNV.html
20561 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20562 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
20563 acquireWinrtDisplayNV( DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
20564 # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
20565
20566 // wrapper function for command vkGetWinrtDisplayNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetWinrtDisplayNV.html
20567 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20568 VULKAN_HPP_NODISCARD Result getWinrtDisplayNV( uint32_t deviceRelativeId,
20569 DisplayKHR * pDisplay,
20570 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
20571 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
20572 // wrapper function for command vkGetWinrtDisplayNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetWinrtDisplayNV.html
20573 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20574 VULKAN_HPP_NODISCARD typename ResultValueType<DisplayKHR>::type getWinrtDisplayNV( uint32_t deviceRelativeId,
20575 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
20576 # ifndef VULKAN_HPP_NO_SMART_HANDLE
20577 // wrapper function for command vkGetWinrtDisplayNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetWinrtDisplayNV.html
20578 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20579 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<DisplayKHR, Dispatch>>::type
20580 getWinrtDisplayNVUnique( uint32_t deviceRelativeId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
20581 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
20582 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
20583 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
20584
20585 #if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
20586 //=== VK_EXT_directfb_surface ===
20587
20588 // wrapper function for command vkGetPhysicalDeviceDirectFBPresentationSupportEXT, see
20589 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDirectFBPresentationSupportEXT.html
20590 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20591 Bool32 getDirectFBPresentationSupportEXT( uint32_t queueFamilyIndex,
20592 IDirectFB * dfb,
20593 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
20594 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
20595 // wrapper function for command vkGetPhysicalDeviceDirectFBPresentationSupportEXT, see
20596 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDirectFBPresentationSupportEXT.html
20597 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20598 Bool32 getDirectFBPresentationSupportEXT( uint32_t queueFamilyIndex,
20599 IDirectFB & dfb,
20600 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
20601 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
20602 #endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
20603
20604 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
20605 //=== VK_QNX_screen_surface ===
20606
20607 // wrapper function for command vkGetPhysicalDeviceScreenPresentationSupportQNX, see
20608 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceScreenPresentationSupportQNX.html
20609 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20610 Bool32 getScreenPresentationSupportQNX( uint32_t queueFamilyIndex,
20611 struct _screen_window * window,
20612 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
20613 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
20614 // wrapper function for command vkGetPhysicalDeviceScreenPresentationSupportQNX, see
20615 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceScreenPresentationSupportQNX.html
20616 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20617 Bool32 getScreenPresentationSupportQNX( uint32_t queueFamilyIndex,
20618 struct _screen_window & window,
20619 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
20620 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
20621 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
20622
20623 //=== VK_ARM_tensors ===
20624
20625 // wrapper function for command vkGetPhysicalDeviceExternalTensorPropertiesARM, see
20626 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalTensorPropertiesARM.html
20627 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20628 void getExternalTensorPropertiesARM( const PhysicalDeviceExternalTensorInfoARM * pExternalTensorInfo,
20629 ExternalTensorPropertiesARM * pExternalTensorProperties,
20630 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
20631 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
20632 // wrapper function for command vkGetPhysicalDeviceExternalTensorPropertiesARM, see
20633 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalTensorPropertiesARM.html
20634 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20635 VULKAN_HPP_NODISCARD ExternalTensorPropertiesARM getExternalTensorPropertiesARM(
20636 const PhysicalDeviceExternalTensorInfoARM & externalTensorInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
20637 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
20638
20639 //=== VK_NV_optical_flow ===
20640
20641 // wrapper function for command vkGetPhysicalDeviceOpticalFlowImageFormatsNV, see
20642 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceOpticalFlowImageFormatsNV.html
20643 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20644 VULKAN_HPP_NODISCARD Result getOpticalFlowImageFormatsNV( const OpticalFlowImageFormatInfoNV * pOpticalFlowImageFormatInfo,
20645 uint32_t * pFormatCount,
20646 OpticalFlowImageFormatPropertiesNV * pImageFormatProperties,
20647 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
20648 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
20649 // wrapper function for command vkGetPhysicalDeviceOpticalFlowImageFormatsNV, see
20650 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceOpticalFlowImageFormatsNV.html
20651 template <typename OpticalFlowImageFormatPropertiesNVAllocator = std::allocator<OpticalFlowImageFormatPropertiesNV>,
20652 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
20653 typename std::enable_if<std::is_same<typename OpticalFlowImageFormatPropertiesNVAllocator::value_type, OpticalFlowImageFormatPropertiesNV>::value,
20654 int>::type = 0,
20655 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20656 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<OpticalFlowImageFormatPropertiesNV, OpticalFlowImageFormatPropertiesNVAllocator>>::type
20657 getOpticalFlowImageFormatsNV( const OpticalFlowImageFormatInfoNV & opticalFlowImageFormatInfo,
20658 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
20659 // wrapper function for command vkGetPhysicalDeviceOpticalFlowImageFormatsNV, see
20660 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceOpticalFlowImageFormatsNV.html
20661 template <typename OpticalFlowImageFormatPropertiesNVAllocator = std::allocator<OpticalFlowImageFormatPropertiesNV>,
20662 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
20663 typename std::enable_if<std::is_same<typename OpticalFlowImageFormatPropertiesNVAllocator::value_type, OpticalFlowImageFormatPropertiesNV>::value,
20664 int>::type = 0,
20665 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20666 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<OpticalFlowImageFormatPropertiesNV, OpticalFlowImageFormatPropertiesNVAllocator>>::type
20667 getOpticalFlowImageFormatsNV( const OpticalFlowImageFormatInfoNV & opticalFlowImageFormatInfo,
20668 OpticalFlowImageFormatPropertiesNVAllocator & opticalFlowImageFormatPropertiesNVAllocator,
20669 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
20670 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
20671
20672 //=== VK_NV_cooperative_vector ===
20673
20674 // wrapper function for command vkGetPhysicalDeviceCooperativeVectorPropertiesNV, see
20675 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeVectorPropertiesNV.html
20676 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20677 VULKAN_HPP_NODISCARD Result getCooperativeVectorPropertiesNV( uint32_t * pPropertyCount,
20678 CooperativeVectorPropertiesNV * pProperties,
20679 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
20680 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
20681 // wrapper function for command vkGetPhysicalDeviceCooperativeVectorPropertiesNV, see
20682 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeVectorPropertiesNV.html
20683 template <
20684 typename CooperativeVectorPropertiesNVAllocator = std::allocator<CooperativeVectorPropertiesNV>,
20685 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
20686 typename std::enable_if<std::is_same<typename CooperativeVectorPropertiesNVAllocator::value_type, CooperativeVectorPropertiesNV>::value, int>::type = 0,
20687 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20688 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<CooperativeVectorPropertiesNV, CooperativeVectorPropertiesNVAllocator>>::type
20689 getCooperativeVectorPropertiesNV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
20690 // wrapper function for command vkGetPhysicalDeviceCooperativeVectorPropertiesNV, see
20691 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeVectorPropertiesNV.html
20692 template <
20693 typename CooperativeVectorPropertiesNVAllocator = std::allocator<CooperativeVectorPropertiesNV>,
20694 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
20695 typename std::enable_if<std::is_same<typename CooperativeVectorPropertiesNVAllocator::value_type, CooperativeVectorPropertiesNV>::value, int>::type = 0,
20696 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20697 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<CooperativeVectorPropertiesNV, CooperativeVectorPropertiesNVAllocator>>::type
20698 getCooperativeVectorPropertiesNV( CooperativeVectorPropertiesNVAllocator & cooperativeVectorPropertiesNVAllocator,
20699 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
20700 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
20701
20702 //=== VK_KHR_cooperative_matrix ===
20703
20704 // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR, see
20705 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR.html
20706 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20707 VULKAN_HPP_NODISCARD Result getCooperativeMatrixPropertiesKHR( uint32_t * pPropertyCount,
20708 CooperativeMatrixPropertiesKHR * pProperties,
20709 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
20710 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
20711 // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR, see
20712 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR.html
20713 template <
20714 typename CooperativeMatrixPropertiesKHRAllocator = std::allocator<CooperativeMatrixPropertiesKHR>,
20715 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
20716 typename std::enable_if<std::is_same<typename CooperativeMatrixPropertiesKHRAllocator::value_type, CooperativeMatrixPropertiesKHR>::value, int>::type = 0,
20717 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20718 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<CooperativeMatrixPropertiesKHR, CooperativeMatrixPropertiesKHRAllocator>>::type
20719 getCooperativeMatrixPropertiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
20720 // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR, see
20721 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR.html
20722 template <
20723 typename CooperativeMatrixPropertiesKHRAllocator = std::allocator<CooperativeMatrixPropertiesKHR>,
20724 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
20725 typename std::enable_if<std::is_same<typename CooperativeMatrixPropertiesKHRAllocator::value_type, CooperativeMatrixPropertiesKHR>::value, int>::type = 0,
20726 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20727 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<CooperativeMatrixPropertiesKHR, CooperativeMatrixPropertiesKHRAllocator>>::type
20728 getCooperativeMatrixPropertiesKHR( CooperativeMatrixPropertiesKHRAllocator & cooperativeMatrixPropertiesKHRAllocator,
20729 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
20730 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
20731
20732 //=== VK_ARM_data_graph ===
20733
20734 // wrapper function for command vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM, see
20735 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM.html
20736 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20737 VULKAN_HPP_NODISCARD Result getQueueFamilyDataGraphPropertiesARM( uint32_t queueFamilyIndex,
20738 uint32_t * pQueueFamilyDataGraphPropertyCount,
20739 QueueFamilyDataGraphPropertiesARM * pQueueFamilyDataGraphProperties,
20740 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
20741 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
20742 // wrapper function for command vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM, see
20743 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM.html
20744 template <typename QueueFamilyDataGraphPropertiesARMAllocator = std::allocator<QueueFamilyDataGraphPropertiesARM>,
20745 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
20746 typename std::enable_if<std::is_same<typename QueueFamilyDataGraphPropertiesARMAllocator::value_type, QueueFamilyDataGraphPropertiesARM>::value,
20747 int>::type = 0,
20748 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20749 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<QueueFamilyDataGraphPropertiesARM, QueueFamilyDataGraphPropertiesARMAllocator>>::type
20750 getQueueFamilyDataGraphPropertiesARM( uint32_t queueFamilyIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
20751 // wrapper function for command vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM, see
20752 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM.html
20753 template <typename QueueFamilyDataGraphPropertiesARMAllocator = std::allocator<QueueFamilyDataGraphPropertiesARM>,
20754 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
20755 typename std::enable_if<std::is_same<typename QueueFamilyDataGraphPropertiesARMAllocator::value_type, QueueFamilyDataGraphPropertiesARM>::value,
20756 int>::type = 0,
20757 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20758 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<QueueFamilyDataGraphPropertiesARM, QueueFamilyDataGraphPropertiesARMAllocator>>::type
20759 getQueueFamilyDataGraphPropertiesARM( uint32_t queueFamilyIndex,
20760 QueueFamilyDataGraphPropertiesARMAllocator & queueFamilyDataGraphPropertiesARMAllocator,
20761 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
20762 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
20763
20764 // wrapper function for command vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM, see
20765 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM.html
20766 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20767 void getQueueFamilyDataGraphProcessingEnginePropertiesARM(
20768 const PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM * pQueueFamilyDataGraphProcessingEngineInfo,
20769 QueueFamilyDataGraphProcessingEnginePropertiesARM * pQueueFamilyDataGraphProcessingEngineProperties,
20770 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
20771 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
20772 // wrapper function for command vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM, see
20773 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM.html
20774 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20775 VULKAN_HPP_NODISCARD QueueFamilyDataGraphProcessingEnginePropertiesARM getQueueFamilyDataGraphProcessingEnginePropertiesARM(
20776 const PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM & queueFamilyDataGraphProcessingEngineInfo,
20777 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
20778 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
20779
20780 //=== VK_KHR_calibrated_timestamps ===
20781
20782 // wrapper function for command vkGetPhysicalDeviceCalibrateableTimeDomainsKHR, see
20783 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCalibrateableTimeDomainsKHR.html
20784 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20785 VULKAN_HPP_NODISCARD Result getCalibrateableTimeDomainsKHR( uint32_t * pTimeDomainCount,
20786 TimeDomainKHR * pTimeDomains,
20787 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
20788 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
20789 // wrapper function for command vkGetPhysicalDeviceCalibrateableTimeDomainsKHR, see
20790 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCalibrateableTimeDomainsKHR.html
20791 template <typename TimeDomainKHRAllocator = std::allocator<TimeDomainKHR>,
20792 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
20793 typename std::enable_if<std::is_same<typename TimeDomainKHRAllocator::value_type, TimeDomainKHR>::value, int>::type = 0,
20794 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20795 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<TimeDomainKHR, TimeDomainKHRAllocator>>::type
20796 getCalibrateableTimeDomainsKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
20797 // wrapper function for command vkGetPhysicalDeviceCalibrateableTimeDomainsKHR, see
20798 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCalibrateableTimeDomainsKHR.html
20799 template <typename TimeDomainKHRAllocator = std::allocator<TimeDomainKHR>,
20800 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
20801 typename std::enable_if<std::is_same<typename TimeDomainKHRAllocator::value_type, TimeDomainKHR>::value, int>::type = 0,
20802 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20803 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<TimeDomainKHR, TimeDomainKHRAllocator>>::type
20804 getCalibrateableTimeDomainsKHR( TimeDomainKHRAllocator & timeDomainKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
20805 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
20806
20807 //=== VK_NV_cooperative_matrix2 ===
20808
20809 // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV, see
20810 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV.html
20811 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20812 VULKAN_HPP_NODISCARD Result
20813 getCooperativeMatrixFlexibleDimensionsPropertiesNV( uint32_t * pPropertyCount,
20814 CooperativeMatrixFlexibleDimensionsPropertiesNV * pProperties,
20815 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
20816 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
20817 // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV, see
20818 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV.html
20819 template <typename CooperativeMatrixFlexibleDimensionsPropertiesNVAllocator = std::allocator<CooperativeMatrixFlexibleDimensionsPropertiesNV>,
20820 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
20821 typename std::enable_if<std::is_same<typename CooperativeMatrixFlexibleDimensionsPropertiesNVAllocator::value_type,
20822 CooperativeMatrixFlexibleDimensionsPropertiesNV>::value,
20823 int>::type = 0,
20824 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20825 VULKAN_HPP_NODISCARD
20826 typename ResultValueType<std::vector<CooperativeMatrixFlexibleDimensionsPropertiesNV, CooperativeMatrixFlexibleDimensionsPropertiesNVAllocator>>::type
20827 getCooperativeMatrixFlexibleDimensionsPropertiesNV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
20828 // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV, see
20829 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV.html
20830 template <typename CooperativeMatrixFlexibleDimensionsPropertiesNVAllocator = std::allocator<CooperativeMatrixFlexibleDimensionsPropertiesNV>,
20831 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
20832 typename std::enable_if<std::is_same<typename CooperativeMatrixFlexibleDimensionsPropertiesNVAllocator::value_type,
20833 CooperativeMatrixFlexibleDimensionsPropertiesNV>::value,
20834 int>::type = 0,
20835 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20836 VULKAN_HPP_NODISCARD
20837 typename ResultValueType<std::vector<CooperativeMatrixFlexibleDimensionsPropertiesNV, CooperativeMatrixFlexibleDimensionsPropertiesNVAllocator>>::type
20838 getCooperativeMatrixFlexibleDimensionsPropertiesNV(
20839 CooperativeMatrixFlexibleDimensionsPropertiesNVAllocator & cooperativeMatrixFlexibleDimensionsPropertiesNVAllocator,
20840 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
20841 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
20842
20843 //=== VK_ARM_performance_counters_by_region ===
20844
20845 // wrapper function for command vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM, see
20846 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM.html
20847 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20848 VULKAN_HPP_NODISCARD Result
20849 enumerateQueueFamilyPerformanceCountersByRegionARM( uint32_t queueFamilyIndex,
20850 uint32_t * pCounterCount,
20851 PerformanceCounterARM * pCounters,
20852 PerformanceCounterDescriptionARM * pCounterDescriptions,
20853 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
20854 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
20855 // wrapper function for command vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM, see
20856 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM.html
20857 template <typename PerformanceCounterARMAllocator = std::allocator<PerformanceCounterARM>,
20858 typename PerformanceCounterDescriptionARMAllocator = std::allocator<PerformanceCounterDescriptionARM>,
20859 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
20860 typename std::enable_if<std::is_same<typename PerformanceCounterARMAllocator::value_type, PerformanceCounterARM>::value &&
20861 std::is_same<typename PerformanceCounterDescriptionARMAllocator::value_type, PerformanceCounterDescriptionARM>::value,
20862 int>::type = 0,
20863 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20864 VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<std::vector<PerformanceCounterARM, PerformanceCounterARMAllocator>,
20865 std::vector<PerformanceCounterDescriptionARM, PerformanceCounterDescriptionARMAllocator>>>::type
20866 enumerateQueueFamilyPerformanceCountersByRegionARM( uint32_t queueFamilyIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
20867 // wrapper function for command vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM, see
20868 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM.html
20869 template <typename PerformanceCounterARMAllocator = std::allocator<PerformanceCounterARM>,
20870 typename PerformanceCounterDescriptionARMAllocator = std::allocator<PerformanceCounterDescriptionARM>,
20871 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
20872 typename std::enable_if<std::is_same<typename PerformanceCounterARMAllocator::value_type, PerformanceCounterARM>::value &&
20873 std::is_same<typename PerformanceCounterDescriptionARMAllocator::value_type, PerformanceCounterDescriptionARM>::value,
20874 int>::type = 0,
20875 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20876 VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<std::vector<PerformanceCounterARM, PerformanceCounterARMAllocator>,
20877 std::vector<PerformanceCounterDescriptionARM, PerformanceCounterDescriptionARMAllocator>>>::type
20878 enumerateQueueFamilyPerformanceCountersByRegionARM( uint32_t queueFamilyIndex,
20879 PerformanceCounterARMAllocator & performanceCounterARMAllocator,
20880 PerformanceCounterDescriptionARMAllocator & performanceCounterDescriptionARMAllocator,
20881 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
20882 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
20883
20884 operator VkPhysicalDevice() const VULKAN_HPP_NOEXCEPT
20885 {
20886 return m_physicalDevice;
20887 }
20888
20889 explicit operator bool() const VULKAN_HPP_NOEXCEPT
20890 {
20891 return m_physicalDevice != VK_NULL_HANDLE;
20892 }
20893
20894 bool operator!() const VULKAN_HPP_NOEXCEPT
20895 {
20896 return m_physicalDevice == VK_NULL_HANDLE;
20897 }
20898
20899 private:
20900 VkPhysicalDevice m_physicalDevice = {};
20901 };
20902
20903 template <>
20904 struct CppType<ObjectType, ObjectType::ePhysicalDevice>
20905 {
20906 using Type = PhysicalDevice;
20907 };
20908
20909 template <>
20910 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::ePhysicalDevice>
20911 {
20912 using Type = PhysicalDevice;
20913 };
20914
20915 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
20916 template <>
20917 struct CppType<VkPhysicalDevice, VK_NULL_HANDLE>
20918 {
20919 using Type = PhysicalDevice;
20920 };
20921 #endif
20922
20923 template <>
20924 struct isVulkanHandleType<PhysicalDevice>
20925 {
20926 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
20927 };
20928
20929 // wrapper class for handle VkInstance, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkInstance.html
20930 class Instance
20931 {
20932 public:
20933 using CType = VkInstance;
20934 using NativeType = VkInstance;
20935
20936 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eInstance;
20937 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eInstance;
20938
20939 public:
20940 Instance() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
20941
20942 Instance( Instance const & rhs ) = default;
20943 Instance & operator=( Instance const & rhs ) = default;
20944
20945 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
20946 Instance( Instance && rhs ) = default;
20947 Instance & operator=( Instance && rhs ) = default;
20948 #else
20949 Instance( Instance && rhs ) VULKAN_HPP_NOEXCEPT : m_instance( exchange( rhs.m_instance, {} ) ) {}
20950
20951 Instance & operator=( Instance && rhs ) VULKAN_HPP_NOEXCEPT
20952 {
20953 m_instance = exchange( rhs.m_instance, {} );
20954 return *this;
20955 }
20956 #endif
20957
20958 VULKAN_HPP_CONSTEXPR Instance( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
20959
20960 Instance( VkInstance instance ) VULKAN_HPP_NOEXCEPT : m_instance( instance ) {}
20961
20962 Instance & operator=( VkInstance instance ) VULKAN_HPP_NOEXCEPT
20963 {
20964 m_instance = instance;
20965 return *this;
20966 }
20967
20968 Instance & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
20969 {
20970 m_instance = {};
20971 return *this;
20972 }
20973
20974 //=== VK_VERSION_1_0 ===
20975
20976 // wrapper function for command vkDestroyInstance, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyInstance.html
20977 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20978 void destroy( const AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
20979 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
20980 // wrapper function for command vkDestroyInstance, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyInstance.html
20981 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20982 void destroy( Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
20983 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
20984 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
20985
20986 // wrapper function for command vkEnumeratePhysicalDevices, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDevices.html
20987 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20988 VULKAN_HPP_NODISCARD Result enumeratePhysicalDevices( uint32_t * pPhysicalDeviceCount,
20989 PhysicalDevice * pPhysicalDevices,
20990 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
20991 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
20992 // wrapper function for command vkEnumeratePhysicalDevices, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDevices.html
20993 template <typename PhysicalDeviceAllocator = std::allocator<PhysicalDevice>,
20994 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
20995 typename std::enable_if<std::is_same<typename PhysicalDeviceAllocator::value_type, PhysicalDevice>::value, int>::type = 0,
20996 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
20997 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PhysicalDevice, PhysicalDeviceAllocator>>::type
20998 enumeratePhysicalDevices( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
20999 // wrapper function for command vkEnumeratePhysicalDevices, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDevices.html
21000 template <typename PhysicalDeviceAllocator = std::allocator<PhysicalDevice>,
21001 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
21002 typename std::enable_if<std::is_same<typename PhysicalDeviceAllocator::value_type, PhysicalDevice>::value, int>::type = 0,
21003 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21004 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PhysicalDevice, PhysicalDeviceAllocator>>::type
21005 enumeratePhysicalDevices( PhysicalDeviceAllocator & physicalDeviceAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
21006 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
21007
21008 // wrapper function for command vkGetInstanceProcAddr, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetInstanceProcAddr.html
21009 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21010 PFN_vkVoidFunction getProcAddr( const char * pName, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
21011 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
21012 // wrapper function for command vkGetInstanceProcAddr, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetInstanceProcAddr.html
21013 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21014 PFN_VoidFunction getProcAddr( const std::string & name, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
21015 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
21016
21017 //=== VK_VERSION_1_1 ===
21018
21019 // wrapper function for command vkEnumeratePhysicalDeviceGroups, see
21020 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceGroups.html
21021 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21022 VULKAN_HPP_NODISCARD Result enumeratePhysicalDeviceGroups( uint32_t * pPhysicalDeviceGroupCount,
21023 PhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties,
21024 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
21025 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
21026 // wrapper function for command vkEnumeratePhysicalDeviceGroups, see
21027 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceGroups.html
21028 template <
21029 typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<PhysicalDeviceGroupProperties>,
21030 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
21031 typename std::enable_if<std::is_same<typename PhysicalDeviceGroupPropertiesAllocator::value_type, PhysicalDeviceGroupProperties>::value, int>::type = 0,
21032 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21033 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type
21034 enumeratePhysicalDeviceGroups( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
21035 // wrapper function for command vkEnumeratePhysicalDeviceGroups, see
21036 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceGroups.html
21037 template <
21038 typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<PhysicalDeviceGroupProperties>,
21039 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
21040 typename std::enable_if<std::is_same<typename PhysicalDeviceGroupPropertiesAllocator::value_type, PhysicalDeviceGroupProperties>::value, int>::type = 0,
21041 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21042 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type
21043 enumeratePhysicalDeviceGroups( PhysicalDeviceGroupPropertiesAllocator & physicalDeviceGroupPropertiesAllocator,
21044 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
21045 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
21046
21047 //=== VK_KHR_surface ===
21048
21049 // wrapper function for command vkDestroySurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySurfaceKHR.html
21050 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21051 void destroySurfaceKHR( SurfaceKHR surface,
21052 const AllocationCallbacks * pAllocator,
21053 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
21054 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
21055 // wrapper function for command vkDestroySurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySurfaceKHR.html
21056 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21057 void destroySurfaceKHR( SurfaceKHR surface VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
21058 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
21059 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
21060 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
21061
21062 // wrapper function for command vkDestroySurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySurfaceKHR.html
21063 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21064 void destroy( SurfaceKHR surface,
21065 const AllocationCallbacks * pAllocator,
21066 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
21067 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
21068 // wrapper function for command vkDestroySurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySurfaceKHR.html
21069 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21070 void destroy( SurfaceKHR surface,
21071 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
21072 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
21073 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
21074
21075 //=== VK_KHR_display ===
21076
21077 // wrapper function for command vkCreateDisplayPlaneSurfaceKHR, see
21078 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDisplayPlaneSurfaceKHR.html
21079 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21080 VULKAN_HPP_NODISCARD Result createDisplayPlaneSurfaceKHR( const DisplaySurfaceCreateInfoKHR * pCreateInfo,
21081 const AllocationCallbacks * pAllocator,
21082 SurfaceKHR * pSurface,
21083 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
21084 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
21085 // wrapper function for command vkCreateDisplayPlaneSurfaceKHR, see
21086 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDisplayPlaneSurfaceKHR.html
21087 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21088 VULKAN_HPP_NODISCARD typename ResultValueType<SurfaceKHR>::type
21089 createDisplayPlaneSurfaceKHR( const DisplaySurfaceCreateInfoKHR & createInfo,
21090 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
21091 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
21092 # ifndef VULKAN_HPP_NO_SMART_HANDLE
21093 // wrapper function for command vkCreateDisplayPlaneSurfaceKHR, see
21094 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDisplayPlaneSurfaceKHR.html
21095 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21096 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
21097 createDisplayPlaneSurfaceKHRUnique( const DisplaySurfaceCreateInfoKHR & createInfo,
21098 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
21099 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
21100 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
21101 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
21102
21103 #if defined( VK_USE_PLATFORM_XLIB_KHR )
21104 //=== VK_KHR_xlib_surface ===
21105
21106 // wrapper function for command vkCreateXlibSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateXlibSurfaceKHR.html
21107 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21108 VULKAN_HPP_NODISCARD Result createXlibSurfaceKHR( const XlibSurfaceCreateInfoKHR * pCreateInfo,
21109 const AllocationCallbacks * pAllocator,
21110 SurfaceKHR * pSurface,
21111 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
21112 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
21113 // wrapper function for command vkCreateXlibSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateXlibSurfaceKHR.html
21114 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21115 VULKAN_HPP_NODISCARD typename ResultValueType<SurfaceKHR>::type
21116 createXlibSurfaceKHR( const XlibSurfaceCreateInfoKHR & createInfo,
21117 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
21118 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
21119 # ifndef VULKAN_HPP_NO_SMART_HANDLE
21120 // wrapper function for command vkCreateXlibSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateXlibSurfaceKHR.html
21121 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21122 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
21123 createXlibSurfaceKHRUnique( const XlibSurfaceCreateInfoKHR & createInfo,
21124 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
21125 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
21126 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
21127 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
21128 #endif /*VK_USE_PLATFORM_XLIB_KHR*/
21129
21130 #if defined( VK_USE_PLATFORM_XCB_KHR )
21131 //=== VK_KHR_xcb_surface ===
21132
21133 // wrapper function for command vkCreateXcbSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateXcbSurfaceKHR.html
21134 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21135 VULKAN_HPP_NODISCARD Result createXcbSurfaceKHR( const XcbSurfaceCreateInfoKHR * pCreateInfo,
21136 const AllocationCallbacks * pAllocator,
21137 SurfaceKHR * pSurface,
21138 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
21139 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
21140 // wrapper function for command vkCreateXcbSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateXcbSurfaceKHR.html
21141 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21142 VULKAN_HPP_NODISCARD typename ResultValueType<SurfaceKHR>::type
21143 createXcbSurfaceKHR( const XcbSurfaceCreateInfoKHR & createInfo,
21144 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
21145 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
21146 # ifndef VULKAN_HPP_NO_SMART_HANDLE
21147 // wrapper function for command vkCreateXcbSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateXcbSurfaceKHR.html
21148 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21149 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
21150 createXcbSurfaceKHRUnique( const XcbSurfaceCreateInfoKHR & createInfo,
21151 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
21152 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
21153 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
21154 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
21155 #endif /*VK_USE_PLATFORM_XCB_KHR*/
21156
21157 #if defined( VK_USE_PLATFORM_WAYLAND_KHR )
21158 //=== VK_KHR_wayland_surface ===
21159
21160 // wrapper function for command vkCreateWaylandSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateWaylandSurfaceKHR.html
21161 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21162 VULKAN_HPP_NODISCARD Result createWaylandSurfaceKHR( const WaylandSurfaceCreateInfoKHR * pCreateInfo,
21163 const AllocationCallbacks * pAllocator,
21164 SurfaceKHR * pSurface,
21165 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
21166 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
21167 // wrapper function for command vkCreateWaylandSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateWaylandSurfaceKHR.html
21168 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21169 VULKAN_HPP_NODISCARD typename ResultValueType<SurfaceKHR>::type
21170 createWaylandSurfaceKHR( const WaylandSurfaceCreateInfoKHR & createInfo,
21171 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
21172 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
21173 # ifndef VULKAN_HPP_NO_SMART_HANDLE
21174 // wrapper function for command vkCreateWaylandSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateWaylandSurfaceKHR.html
21175 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21176 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
21177 createWaylandSurfaceKHRUnique( const WaylandSurfaceCreateInfoKHR & createInfo,
21178 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
21179 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
21180 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
21181 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
21182 #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
21183
21184 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
21185 //=== VK_KHR_android_surface ===
21186
21187 // wrapper function for command vkCreateAndroidSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAndroidSurfaceKHR.html
21188 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21189 VULKAN_HPP_NODISCARD Result createAndroidSurfaceKHR( const AndroidSurfaceCreateInfoKHR * pCreateInfo,
21190 const AllocationCallbacks * pAllocator,
21191 SurfaceKHR * pSurface,
21192 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
21193 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
21194 // wrapper function for command vkCreateAndroidSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAndroidSurfaceKHR.html
21195 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21196 VULKAN_HPP_NODISCARD typename ResultValueType<SurfaceKHR>::type
21197 createAndroidSurfaceKHR( const AndroidSurfaceCreateInfoKHR & createInfo,
21198 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
21199 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
21200 # ifndef VULKAN_HPP_NO_SMART_HANDLE
21201 // wrapper function for command vkCreateAndroidSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAndroidSurfaceKHR.html
21202 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21203 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
21204 createAndroidSurfaceKHRUnique( const AndroidSurfaceCreateInfoKHR & createInfo,
21205 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
21206 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
21207 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
21208 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
21209 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
21210
21211 #if defined( VK_USE_PLATFORM_WIN32_KHR )
21212 //=== VK_KHR_win32_surface ===
21213
21214 // wrapper function for command vkCreateWin32SurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateWin32SurfaceKHR.html
21215 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21216 VULKAN_HPP_NODISCARD Result createWin32SurfaceKHR( const Win32SurfaceCreateInfoKHR * pCreateInfo,
21217 const AllocationCallbacks * pAllocator,
21218 SurfaceKHR * pSurface,
21219 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
21220 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
21221 // wrapper function for command vkCreateWin32SurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateWin32SurfaceKHR.html
21222 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21223 VULKAN_HPP_NODISCARD typename ResultValueType<SurfaceKHR>::type
21224 createWin32SurfaceKHR( const Win32SurfaceCreateInfoKHR & createInfo,
21225 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
21226 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
21227 # ifndef VULKAN_HPP_NO_SMART_HANDLE
21228 // wrapper function for command vkCreateWin32SurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateWin32SurfaceKHR.html
21229 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21230 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
21231 createWin32SurfaceKHRUnique( const Win32SurfaceCreateInfoKHR & createInfo,
21232 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
21233 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
21234 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
21235 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
21236 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
21237
21238 //=== VK_EXT_debug_report ===
21239
21240 // wrapper function for command vkCreateDebugReportCallbackEXT, see
21241 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDebugReportCallbackEXT.html
21242 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21243 VULKAN_HPP_NODISCARD Result createDebugReportCallbackEXT( const DebugReportCallbackCreateInfoEXT * pCreateInfo,
21244 const AllocationCallbacks * pAllocator,
21245 DebugReportCallbackEXT * pCallback,
21246 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
21247 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
21248 // wrapper function for command vkCreateDebugReportCallbackEXT, see
21249 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDebugReportCallbackEXT.html
21250 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21251 VULKAN_HPP_NODISCARD typename ResultValueType<DebugReportCallbackEXT>::type
21252 createDebugReportCallbackEXT( const DebugReportCallbackCreateInfoEXT & createInfo,
21253 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
21254 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
21255 # ifndef VULKAN_HPP_NO_SMART_HANDLE
21256 // wrapper function for command vkCreateDebugReportCallbackEXT, see
21257 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDebugReportCallbackEXT.html
21258 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21259 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<DebugReportCallbackEXT, Dispatch>>::type
21260 createDebugReportCallbackEXTUnique( const DebugReportCallbackCreateInfoEXT & createInfo,
21261 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
21262 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
21263 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
21264 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
21265
21266 // wrapper function for command vkDestroyDebugReportCallbackEXT, see
21267 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDebugReportCallbackEXT.html
21268 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21269 void destroyDebugReportCallbackEXT( DebugReportCallbackEXT callback,
21270 const AllocationCallbacks * pAllocator,
21271 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
21272 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
21273 // wrapper function for command vkDestroyDebugReportCallbackEXT, see
21274 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDebugReportCallbackEXT.html
21275 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21276 void destroyDebugReportCallbackEXT( DebugReportCallbackEXT callback VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
21277 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
21278 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
21279 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
21280
21281 // wrapper function for command vkDestroyDebugReportCallbackEXT, see
21282 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDebugReportCallbackEXT.html
21283 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21284 void destroy( DebugReportCallbackEXT callback,
21285 const AllocationCallbacks * pAllocator,
21286 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
21287 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
21288 // wrapper function for command vkDestroyDebugReportCallbackEXT, see
21289 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDebugReportCallbackEXT.html
21290 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21291 void destroy( DebugReportCallbackEXT callback,
21292 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
21293 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
21294 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
21295
21296 // wrapper function for command vkDebugReportMessageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDebugReportMessageEXT.html
21297 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21298 void debugReportMessageEXT( DebugReportFlagsEXT flags,
21299 DebugReportObjectTypeEXT objectType,
21300 uint64_t object,
21301 size_t location,
21302 int32_t messageCode,
21303 const char * pLayerPrefix,
21304 const char * pMessage,
21305 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
21306 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
21307 // wrapper function for command vkDebugReportMessageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDebugReportMessageEXT.html
21308 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21309 void debugReportMessageEXT( DebugReportFlagsEXT flags,
21310 DebugReportObjectTypeEXT objectType,
21311 uint64_t object,
21312 size_t location,
21313 int32_t messageCode,
21314 const std::string & layerPrefix,
21315 const std::string & message,
21316 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
21317 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
21318
21319 #if defined( VK_USE_PLATFORM_GGP )
21320 //=== VK_GGP_stream_descriptor_surface ===
21321
21322 // wrapper function for command vkCreateStreamDescriptorSurfaceGGP, see
21323 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateStreamDescriptorSurfaceGGP.html
21324 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21325 VULKAN_HPP_NODISCARD Result createStreamDescriptorSurfaceGGP( const StreamDescriptorSurfaceCreateInfoGGP * pCreateInfo,
21326 const AllocationCallbacks * pAllocator,
21327 SurfaceKHR * pSurface,
21328 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
21329 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
21330 // wrapper function for command vkCreateStreamDescriptorSurfaceGGP, see
21331 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateStreamDescriptorSurfaceGGP.html
21332 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21333 VULKAN_HPP_NODISCARD typename ResultValueType<SurfaceKHR>::type
21334 createStreamDescriptorSurfaceGGP( const StreamDescriptorSurfaceCreateInfoGGP & createInfo,
21335 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
21336 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
21337 # ifndef VULKAN_HPP_NO_SMART_HANDLE
21338 // wrapper function for command vkCreateStreamDescriptorSurfaceGGP, see
21339 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateStreamDescriptorSurfaceGGP.html
21340 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21341 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
21342 createStreamDescriptorSurfaceGGPUnique( const StreamDescriptorSurfaceCreateInfoGGP & createInfo,
21343 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
21344 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
21345 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
21346 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
21347 #endif /*VK_USE_PLATFORM_GGP*/
21348
21349 #if defined( VK_USE_PLATFORM_VI_NN )
21350 //=== VK_NN_vi_surface ===
21351
21352 // wrapper function for command vkCreateViSurfaceNN, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateViSurfaceNN.html
21353 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21354 VULKAN_HPP_NODISCARD Result createViSurfaceNN( const ViSurfaceCreateInfoNN * pCreateInfo,
21355 const AllocationCallbacks * pAllocator,
21356 SurfaceKHR * pSurface,
21357 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
21358 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
21359 // wrapper function for command vkCreateViSurfaceNN, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateViSurfaceNN.html
21360 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21361 VULKAN_HPP_NODISCARD typename ResultValueType<SurfaceKHR>::type
21362 createViSurfaceNN( const ViSurfaceCreateInfoNN & createInfo,
21363 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
21364 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
21365 # ifndef VULKAN_HPP_NO_SMART_HANDLE
21366 // wrapper function for command vkCreateViSurfaceNN, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateViSurfaceNN.html
21367 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21368 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
21369 createViSurfaceNNUnique( const ViSurfaceCreateInfoNN & createInfo,
21370 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
21371 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
21372 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
21373 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
21374 #endif /*VK_USE_PLATFORM_VI_NN*/
21375
21376 //=== VK_KHR_device_group_creation ===
21377
21378 // wrapper function for command vkEnumeratePhysicalDeviceGroupsKHR, see
21379 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceGroupsKHR.html
21380 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21381 VULKAN_HPP_NODISCARD Result enumeratePhysicalDeviceGroupsKHR( uint32_t * pPhysicalDeviceGroupCount,
21382 PhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties,
21383 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
21384 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
21385 // wrapper function for command vkEnumeratePhysicalDeviceGroupsKHR, see
21386 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceGroupsKHR.html
21387 template <
21388 typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<PhysicalDeviceGroupProperties>,
21389 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
21390 typename std::enable_if<std::is_same<typename PhysicalDeviceGroupPropertiesAllocator::value_type, PhysicalDeviceGroupProperties>::value, int>::type = 0,
21391 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21392 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type
21393 enumeratePhysicalDeviceGroupsKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
21394 // wrapper function for command vkEnumeratePhysicalDeviceGroupsKHR, see
21395 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceGroupsKHR.html
21396 template <
21397 typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<PhysicalDeviceGroupProperties>,
21398 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
21399 typename std::enable_if<std::is_same<typename PhysicalDeviceGroupPropertiesAllocator::value_type, PhysicalDeviceGroupProperties>::value, int>::type = 0,
21400 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21401 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type
21402 enumeratePhysicalDeviceGroupsKHR( PhysicalDeviceGroupPropertiesAllocator & physicalDeviceGroupPropertiesAllocator,
21403 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
21404 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
21405
21406 #if defined( VK_USE_PLATFORM_IOS_MVK )
21407 //=== VK_MVK_ios_surface ===
21408
21409 // wrapper function for command vkCreateIOSSurfaceMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIOSSurfaceMVK.html
21410 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21411 VULKAN_HPP_NODISCARD Result createIOSSurfaceMVK( const IOSSurfaceCreateInfoMVK * pCreateInfo,
21412 const AllocationCallbacks * pAllocator,
21413 SurfaceKHR * pSurface,
21414 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
21415 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
21416 // wrapper function for command vkCreateIOSSurfaceMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIOSSurfaceMVK.html
21417 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21418 VULKAN_HPP_NODISCARD typename ResultValueType<SurfaceKHR>::type
21419 createIOSSurfaceMVK( const IOSSurfaceCreateInfoMVK & createInfo,
21420 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
21421 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
21422 # ifndef VULKAN_HPP_NO_SMART_HANDLE
21423 // wrapper function for command vkCreateIOSSurfaceMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIOSSurfaceMVK.html
21424 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21425 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
21426 createIOSSurfaceMVKUnique( const IOSSurfaceCreateInfoMVK & createInfo,
21427 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
21428 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
21429 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
21430 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
21431 #endif /*VK_USE_PLATFORM_IOS_MVK*/
21432
21433 #if defined( VK_USE_PLATFORM_MACOS_MVK )
21434 //=== VK_MVK_macos_surface ===
21435
21436 // wrapper function for command vkCreateMacOSSurfaceMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMacOSSurfaceMVK.html
21437 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21438 VULKAN_HPP_NODISCARD Result createMacOSSurfaceMVK( const MacOSSurfaceCreateInfoMVK * pCreateInfo,
21439 const AllocationCallbacks * pAllocator,
21440 SurfaceKHR * pSurface,
21441 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
21442 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
21443 // wrapper function for command vkCreateMacOSSurfaceMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMacOSSurfaceMVK.html
21444 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21445 VULKAN_HPP_NODISCARD typename ResultValueType<SurfaceKHR>::type
21446 createMacOSSurfaceMVK( const MacOSSurfaceCreateInfoMVK & createInfo,
21447 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
21448 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
21449 # ifndef VULKAN_HPP_NO_SMART_HANDLE
21450 // wrapper function for command vkCreateMacOSSurfaceMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMacOSSurfaceMVK.html
21451 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21452 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
21453 createMacOSSurfaceMVKUnique( const MacOSSurfaceCreateInfoMVK & createInfo,
21454 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
21455 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
21456 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
21457 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
21458 #endif /*VK_USE_PLATFORM_MACOS_MVK*/
21459
21460 //=== VK_EXT_debug_utils ===
21461
21462 // wrapper function for command vkCreateDebugUtilsMessengerEXT, see
21463 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDebugUtilsMessengerEXT.html
21464 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21465 VULKAN_HPP_NODISCARD Result createDebugUtilsMessengerEXT( const DebugUtilsMessengerCreateInfoEXT * pCreateInfo,
21466 const AllocationCallbacks * pAllocator,
21467 DebugUtilsMessengerEXT * pMessenger,
21468 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
21469 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
21470 // wrapper function for command vkCreateDebugUtilsMessengerEXT, see
21471 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDebugUtilsMessengerEXT.html
21472 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21473 VULKAN_HPP_NODISCARD typename ResultValueType<DebugUtilsMessengerEXT>::type
21474 createDebugUtilsMessengerEXT( const DebugUtilsMessengerCreateInfoEXT & createInfo,
21475 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
21476 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
21477 # ifndef VULKAN_HPP_NO_SMART_HANDLE
21478 // wrapper function for command vkCreateDebugUtilsMessengerEXT, see
21479 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDebugUtilsMessengerEXT.html
21480 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21481 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<DebugUtilsMessengerEXT, Dispatch>>::type
21482 createDebugUtilsMessengerEXTUnique( const DebugUtilsMessengerCreateInfoEXT & createInfo,
21483 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
21484 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
21485 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
21486 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
21487
21488 // wrapper function for command vkDestroyDebugUtilsMessengerEXT, see
21489 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDebugUtilsMessengerEXT.html
21490 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21491 void destroyDebugUtilsMessengerEXT( DebugUtilsMessengerEXT messenger,
21492 const AllocationCallbacks * pAllocator,
21493 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
21494 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
21495 // wrapper function for command vkDestroyDebugUtilsMessengerEXT, see
21496 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDebugUtilsMessengerEXT.html
21497 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21498 void destroyDebugUtilsMessengerEXT( DebugUtilsMessengerEXT messenger VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
21499 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
21500 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
21501 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
21502
21503 // wrapper function for command vkDestroyDebugUtilsMessengerEXT, see
21504 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDebugUtilsMessengerEXT.html
21505 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21506 void destroy( DebugUtilsMessengerEXT messenger,
21507 const AllocationCallbacks * pAllocator,
21508 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
21509 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
21510 // wrapper function for command vkDestroyDebugUtilsMessengerEXT, see
21511 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDebugUtilsMessengerEXT.html
21512 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21513 void destroy( DebugUtilsMessengerEXT messenger,
21514 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
21515 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
21516 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
21517
21518 // wrapper function for command vkSubmitDebugUtilsMessageEXT, see
21519 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSubmitDebugUtilsMessageEXT.html
21520 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21521 void submitDebugUtilsMessageEXT( DebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
21522 DebugUtilsMessageTypeFlagsEXT messageTypes,
21523 const DebugUtilsMessengerCallbackDataEXT * pCallbackData,
21524 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
21525 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
21526 // wrapper function for command vkSubmitDebugUtilsMessageEXT, see
21527 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSubmitDebugUtilsMessageEXT.html
21528 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21529 void submitDebugUtilsMessageEXT( DebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
21530 DebugUtilsMessageTypeFlagsEXT messageTypes,
21531 const DebugUtilsMessengerCallbackDataEXT & callbackData,
21532 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
21533 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
21534
21535 #if defined( VK_USE_PLATFORM_FUCHSIA )
21536 //=== VK_FUCHSIA_imagepipe_surface ===
21537
21538 // wrapper function for command vkCreateImagePipeSurfaceFUCHSIA, see
21539 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImagePipeSurfaceFUCHSIA.html
21540 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21541 VULKAN_HPP_NODISCARD Result createImagePipeSurfaceFUCHSIA( const ImagePipeSurfaceCreateInfoFUCHSIA * pCreateInfo,
21542 const AllocationCallbacks * pAllocator,
21543 SurfaceKHR * pSurface,
21544 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
21545 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
21546 // wrapper function for command vkCreateImagePipeSurfaceFUCHSIA, see
21547 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImagePipeSurfaceFUCHSIA.html
21548 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21549 VULKAN_HPP_NODISCARD typename ResultValueType<SurfaceKHR>::type
21550 createImagePipeSurfaceFUCHSIA( const ImagePipeSurfaceCreateInfoFUCHSIA & createInfo,
21551 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
21552 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
21553 # ifndef VULKAN_HPP_NO_SMART_HANDLE
21554 // wrapper function for command vkCreateImagePipeSurfaceFUCHSIA, see
21555 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImagePipeSurfaceFUCHSIA.html
21556 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21557 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
21558 createImagePipeSurfaceFUCHSIAUnique( const ImagePipeSurfaceCreateInfoFUCHSIA & createInfo,
21559 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
21560 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
21561 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
21562 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
21563 #endif /*VK_USE_PLATFORM_FUCHSIA*/
21564
21565 #if defined( VK_USE_PLATFORM_METAL_EXT )
21566 //=== VK_EXT_metal_surface ===
21567
21568 // wrapper function for command vkCreateMetalSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMetalSurfaceEXT.html
21569 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21570 VULKAN_HPP_NODISCARD Result createMetalSurfaceEXT( const MetalSurfaceCreateInfoEXT * pCreateInfo,
21571 const AllocationCallbacks * pAllocator,
21572 SurfaceKHR * pSurface,
21573 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
21574 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
21575 // wrapper function for command vkCreateMetalSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMetalSurfaceEXT.html
21576 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21577 VULKAN_HPP_NODISCARD typename ResultValueType<SurfaceKHR>::type
21578 createMetalSurfaceEXT( const MetalSurfaceCreateInfoEXT & createInfo,
21579 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
21580 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
21581 # ifndef VULKAN_HPP_NO_SMART_HANDLE
21582 // wrapper function for command vkCreateMetalSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMetalSurfaceEXT.html
21583 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21584 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
21585 createMetalSurfaceEXTUnique( const MetalSurfaceCreateInfoEXT & createInfo,
21586 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
21587 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
21588 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
21589 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
21590 #endif /*VK_USE_PLATFORM_METAL_EXT*/
21591
21592 //=== VK_EXT_headless_surface ===
21593
21594 // wrapper function for command vkCreateHeadlessSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateHeadlessSurfaceEXT.html
21595 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21596 VULKAN_HPP_NODISCARD Result createHeadlessSurfaceEXT( const HeadlessSurfaceCreateInfoEXT * pCreateInfo,
21597 const AllocationCallbacks * pAllocator,
21598 SurfaceKHR * pSurface,
21599 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
21600 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
21601 // wrapper function for command vkCreateHeadlessSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateHeadlessSurfaceEXT.html
21602 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21603 VULKAN_HPP_NODISCARD typename ResultValueType<SurfaceKHR>::type
21604 createHeadlessSurfaceEXT( const HeadlessSurfaceCreateInfoEXT & createInfo,
21605 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
21606 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
21607 # ifndef VULKAN_HPP_NO_SMART_HANDLE
21608 // wrapper function for command vkCreateHeadlessSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateHeadlessSurfaceEXT.html
21609 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21610 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
21611 createHeadlessSurfaceEXTUnique( const HeadlessSurfaceCreateInfoEXT & createInfo,
21612 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
21613 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
21614 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
21615 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
21616
21617 #if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
21618 //=== VK_EXT_directfb_surface ===
21619
21620 // wrapper function for command vkCreateDirectFBSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDirectFBSurfaceEXT.html
21621 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21622 VULKAN_HPP_NODISCARD Result createDirectFBSurfaceEXT( const DirectFBSurfaceCreateInfoEXT * pCreateInfo,
21623 const AllocationCallbacks * pAllocator,
21624 SurfaceKHR * pSurface,
21625 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
21626 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
21627 // wrapper function for command vkCreateDirectFBSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDirectFBSurfaceEXT.html
21628 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21629 VULKAN_HPP_NODISCARD typename ResultValueType<SurfaceKHR>::type
21630 createDirectFBSurfaceEXT( const DirectFBSurfaceCreateInfoEXT & createInfo,
21631 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
21632 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
21633 # ifndef VULKAN_HPP_NO_SMART_HANDLE
21634 // wrapper function for command vkCreateDirectFBSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDirectFBSurfaceEXT.html
21635 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21636 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
21637 createDirectFBSurfaceEXTUnique( const DirectFBSurfaceCreateInfoEXT & createInfo,
21638 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
21639 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
21640 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
21641 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
21642 #endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
21643
21644 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
21645 //=== VK_QNX_screen_surface ===
21646
21647 // wrapper function for command vkCreateScreenSurfaceQNX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateScreenSurfaceQNX.html
21648 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21649 VULKAN_HPP_NODISCARD Result createScreenSurfaceQNX( const ScreenSurfaceCreateInfoQNX * pCreateInfo,
21650 const AllocationCallbacks * pAllocator,
21651 SurfaceKHR * pSurface,
21652 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
21653 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
21654 // wrapper function for command vkCreateScreenSurfaceQNX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateScreenSurfaceQNX.html
21655 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21656 VULKAN_HPP_NODISCARD typename ResultValueType<SurfaceKHR>::type
21657 createScreenSurfaceQNX( const ScreenSurfaceCreateInfoQNX & createInfo,
21658 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
21659 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
21660 # ifndef VULKAN_HPP_NO_SMART_HANDLE
21661 // wrapper function for command vkCreateScreenSurfaceQNX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateScreenSurfaceQNX.html
21662 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21663 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
21664 createScreenSurfaceQNXUnique( const ScreenSurfaceCreateInfoQNX & createInfo,
21665 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
21666 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
21667 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
21668 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
21669 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
21670
21671 #if defined( VK_USE_PLATFORM_OHOS )
21672 //=== VK_OHOS_surface ===
21673
21674 // wrapper function for command vkCreateSurfaceOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSurfaceOHOS.html
21675 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21676 VULKAN_HPP_NODISCARD Result createSurfaceOHOS( const SurfaceCreateInfoOHOS * pCreateInfo,
21677 const AllocationCallbacks * pAllocator,
21678 SurfaceKHR * pSurface,
21679 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
21680 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
21681 // wrapper function for command vkCreateSurfaceOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSurfaceOHOS.html
21682 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21683 VULKAN_HPP_NODISCARD typename ResultValueType<SurfaceKHR>::type
21684 createSurfaceOHOS( const SurfaceCreateInfoOHOS & createInfo,
21685 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
21686 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
21687 # ifndef VULKAN_HPP_NO_SMART_HANDLE
21688 // wrapper function for command vkCreateSurfaceOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSurfaceOHOS.html
21689 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21690 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
21691 createSurfaceOHOSUnique( const SurfaceCreateInfoOHOS & createInfo,
21692 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
21693 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
21694 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
21695 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
21696 #endif /*VK_USE_PLATFORM_OHOS*/
21697
21698 operator VkInstance() const VULKAN_HPP_NOEXCEPT
21699 {
21700 return m_instance;
21701 }
21702
21703 explicit operator bool() const VULKAN_HPP_NOEXCEPT
21704 {
21705 return m_instance != VK_NULL_HANDLE;
21706 }
21707
21708 bool operator!() const VULKAN_HPP_NOEXCEPT
21709 {
21710 return m_instance == VK_NULL_HANDLE;
21711 }
21712
21713 private:
21714 VkInstance m_instance = {};
21715 };
21716
21717 template <>
21718 struct CppType<ObjectType, ObjectType::eInstance>
21719 {
21720 using Type = Instance;
21721 };
21722
21723 template <>
21724 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eInstance>
21725 {
21726 using Type = Instance;
21727 };
21728
21729 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
21730 template <>
21731 struct CppType<VkInstance, VK_NULL_HANDLE>
21732 {
21733 using Type = Instance;
21734 };
21735 #endif
21736
21737 template <>
21738 struct isVulkanHandleType<Instance>
21739 {
21740 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
21741 };
21742
21743 //=== VK_VERSION_1_0 ===
21744
21745 // wrapper function for command vkCreateInstance, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateInstance.html
21746 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21747 VULKAN_HPP_NODISCARD Result createInstance( const InstanceCreateInfo * pCreateInfo,
21748 const AllocationCallbacks * pAllocator,
21749 Instance * pInstance,
21750 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT;
21751 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
21752 // wrapper function for command vkCreateInstance, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateInstance.html
21753 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21754 VULKAN_HPP_NODISCARD typename ResultValueType<Instance>::type
21755 createInstance( const InstanceCreateInfo & createInfo,
21756 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
21757 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
21758 # ifndef VULKAN_HPP_NO_SMART_HANDLE
21759 // wrapper function for command vkCreateInstance, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateInstance.html
21760 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21761 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<Instance, Dispatch>>::type
21762 createInstanceUnique( const InstanceCreateInfo & createInfo,
21763 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
21764 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
21765 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
21766 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
21767
21768 // wrapper function for command vkEnumerateInstanceExtensionProperties, see
21769 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceExtensionProperties.html
21770 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21771 VULKAN_HPP_NODISCARD Result enumerateInstanceExtensionProperties( const char * pLayerName,
21772 uint32_t * pPropertyCount,
21773 ExtensionProperties * pProperties,
21774 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT;
21775 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
21776 // wrapper function for command vkEnumerateInstanceExtensionProperties, see
21777 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceExtensionProperties.html
21778 template <typename ExtensionPropertiesAllocator = std::allocator<ExtensionProperties>,
21779 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
21780 typename std::enable_if<std::is_same<typename ExtensionPropertiesAllocator::value_type, ExtensionProperties>::value, int>::type = 0,
21781 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21782 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<ExtensionProperties, ExtensionPropertiesAllocator>>::type
21783 enumerateInstanceExtensionProperties( Optional<const std::string> layerName VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
21784 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
21785 // wrapper function for command vkEnumerateInstanceExtensionProperties, see
21786 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceExtensionProperties.html
21787 template <typename ExtensionPropertiesAllocator = std::allocator<ExtensionProperties>,
21788 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
21789 typename std::enable_if<std::is_same<typename ExtensionPropertiesAllocator::value_type, ExtensionProperties>::value, int>::type = 0,
21790 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21791 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<ExtensionProperties, ExtensionPropertiesAllocator>>::type
21792 enumerateInstanceExtensionProperties( Optional<const std::string> layerName,
21793 ExtensionPropertiesAllocator & extensionPropertiesAllocator,
21794 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
21795 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
21796
21797 // wrapper function for command vkEnumerateInstanceLayerProperties, see
21798 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceLayerProperties.html
21799 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21800 VULKAN_HPP_NODISCARD Result enumerateInstanceLayerProperties( uint32_t * pPropertyCount,
21801 LayerProperties * pProperties,
21802 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT;
21803 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
21804 // wrapper function for command vkEnumerateInstanceLayerProperties, see
21805 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceLayerProperties.html
21806 template <typename LayerPropertiesAllocator = std::allocator<LayerProperties>,
21807 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
21808 typename std::enable_if<std::is_same<typename LayerPropertiesAllocator::value_type, LayerProperties>::value, int>::type = 0,
21809 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21810 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<LayerProperties, LayerPropertiesAllocator>>::type
21811 enumerateInstanceLayerProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
21812 // wrapper function for command vkEnumerateInstanceLayerProperties, see
21813 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceLayerProperties.html
21814 template <typename LayerPropertiesAllocator = std::allocator<LayerProperties>,
21815 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
21816 typename std::enable_if<std::is_same<typename LayerPropertiesAllocator::value_type, LayerProperties>::value, int>::type = 0,
21817 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21818 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<LayerProperties, LayerPropertiesAllocator>>::type
21819 enumerateInstanceLayerProperties( LayerPropertiesAllocator & layerPropertiesAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
21820 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
21821
21822 //=== VK_VERSION_1_1 ===
21823
21824 // wrapper function for command vkEnumerateInstanceVersion, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceVersion.html
21825 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21826 VULKAN_HPP_NODISCARD Result enumerateInstanceVersion( uint32_t * pApiVersion,
21827 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT;
21828 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
21829 // wrapper function for command vkEnumerateInstanceVersion, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceVersion.html
21830 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
21831 VULKAN_HPP_NODISCARD typename ResultValueType<uint32_t>::type enumerateInstanceVersion( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
21832 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
21833
21834 // operators to compare VULKAN_HPP_NAMESPACE::-handles
21835 template <typename T, typename std::enable_if<isVulkanHandleType<T>::value, int>::type = 0>
21836 bool operator==( T const & lhs, T const & rhs )
21837 {
21838 return static_cast<typename T::NativeType>( lhs ) == static_cast<typename T::NativeType>( rhs );
21839 }
21840
21841 template <typename T, typename std::enable_if<isVulkanHandleType<T>::value, int>::type = 0>
21842 bool operator!=( T const & lhs, T const & rhs )
21843 {
21844 return static_cast<typename T::NativeType>( lhs ) != static_cast<typename T::NativeType>( rhs );
21845 }
21846
21847 template <typename T, typename std::enable_if<isVulkanHandleType<T>::value, int>::type = 0>
21848 bool operator<( T const & lhs, T const & rhs )
21849 {
21850 return static_cast<typename T::NativeType>( lhs ) < static_cast<typename T::NativeType>( rhs );
21851 }
21852
21853 template <typename T, typename std::enable_if<isVulkanHandleType<T>::value, int>::type = 0>
21854 bool operator<=( T const & lhs, T const & rhs )
21855 {
21856 return static_cast<typename T::NativeType>( lhs ) <= static_cast<typename T::NativeType>( rhs );
21857 }
21858
21859 template <typename T, typename std::enable_if<isVulkanHandleType<T>::value, int>::type = 0>
21860 bool operator>( T const & lhs, T const & rhs )
21861 {
21862 return static_cast<typename T::NativeType>( lhs ) > static_cast<typename T::NativeType>( rhs );
21863 }
21864
21865 template <typename T, typename std::enable_if<isVulkanHandleType<T>::value, int>::type = 0>
21866 bool operator>=( T const & lhs, T const & rhs )
21867 {
21868 return static_cast<typename T::NativeType>( lhs ) >= static_cast<typename T::NativeType>( rhs );
21869 }
21870
21871 template <typename T, typename std::enable_if<isVulkanHandleType<T>::value, int>::type = 0>
21872 bool operator==( T const & v, std::nullptr_t )
21873 {
21874 return !v;
21875 }
21876
21877 template <typename T, typename std::enable_if<isVulkanHandleType<T>::value, int>::type = 0>
21878 bool operator==( std::nullptr_t, T const & v )
21879 {
21880 return !v;
21881 }
21882
21883 template <typename T, typename std::enable_if<isVulkanHandleType<T>::value, int>::type = 0>
21884 bool operator!=( T const & v, std::nullptr_t )
21885 {
21886 return !!v;
21887 }
21888
21889 template <typename T, typename std::enable_if<isVulkanHandleType<T>::value, int>::type = 0>
21890 bool operator!=( std::nullptr_t, T const & v )
21891 {
21892 return !!v;
21893 }
21894 } // namespace VULKAN_HPP_NAMESPACE
21895 #endif