1 // Copyright 2015-2023 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 namespace VULKAN_HPP_NAMESPACE
12 {
13
14 //===================================
15 //=== STRUCT forward declarations ===
16 //===================================
17
18
19 //=== VK_VERSION_1_0 ===
20 struct Extent2D;
21 struct Extent3D;
22 struct Offset2D;
23 struct Offset3D;
24 struct Rect2D;
25 struct BaseInStructure;
26 struct BaseOutStructure;
27 struct BufferMemoryBarrier;
28 struct DispatchIndirectCommand;
29 struct DrawIndexedIndirectCommand;
30 struct DrawIndirectCommand;
31 struct ImageMemoryBarrier;
32 struct MemoryBarrier;
33 struct PipelineCacheHeaderVersionOne;
34 struct AllocationCallbacks;
35 struct ApplicationInfo;
36 struct FormatProperties;
37 struct ImageFormatProperties;
38 struct InstanceCreateInfo;
39 struct MemoryHeap;
40 struct MemoryType;
41 struct PhysicalDeviceFeatures;
42 struct PhysicalDeviceLimits;
43 struct PhysicalDeviceMemoryProperties;
44 struct PhysicalDeviceProperties;
45 struct PhysicalDeviceSparseProperties;
46 struct QueueFamilyProperties;
47 struct DeviceCreateInfo;
48 struct DeviceQueueCreateInfo;
49 struct ExtensionProperties;
50 struct LayerProperties;
51 struct SubmitInfo;
52 struct MappedMemoryRange;
53 struct MemoryAllocateInfo;
54 struct MemoryRequirements;
55 struct BindSparseInfo;
56 struct ImageSubresource;
57 struct SparseBufferMemoryBindInfo;
58 struct SparseImageFormatProperties;
59 struct SparseImageMemoryBind;
60 struct SparseImageMemoryBindInfo;
61 struct SparseImageMemoryRequirements;
62 struct SparseImageOpaqueMemoryBindInfo;
63 struct SparseMemoryBind;
64 struct FenceCreateInfo;
65 struct SemaphoreCreateInfo;
66 struct EventCreateInfo;
67 struct QueryPoolCreateInfo;
68 struct BufferCreateInfo;
69 struct BufferViewCreateInfo;
70 struct ImageCreateInfo;
71 struct SubresourceLayout;
72 struct ComponentMapping;
73 struct ImageSubresourceRange;
74 struct ImageViewCreateInfo;
75 struct ShaderModuleCreateInfo;
76 struct PipelineCacheCreateInfo;
77 struct ComputePipelineCreateInfo;
78 struct GraphicsPipelineCreateInfo;
79 struct PipelineColorBlendAttachmentState;
80 struct PipelineColorBlendStateCreateInfo;
81 struct PipelineDepthStencilStateCreateInfo;
82 struct PipelineDynamicStateCreateInfo;
83 struct PipelineInputAssemblyStateCreateInfo;
84 struct PipelineMultisampleStateCreateInfo;
85 struct PipelineRasterizationStateCreateInfo;
86 struct PipelineShaderStageCreateInfo;
87 struct PipelineTessellationStateCreateInfo;
88 struct PipelineVertexInputStateCreateInfo;
89 struct PipelineViewportStateCreateInfo;
90 struct SpecializationInfo;
91 struct SpecializationMapEntry;
92 struct StencilOpState;
93 struct VertexInputAttributeDescription;
94 struct VertexInputBindingDescription;
95 struct Viewport;
96 struct PipelineLayoutCreateInfo;
97 struct PushConstantRange;
98 struct SamplerCreateInfo;
99 struct CopyDescriptorSet;
100 struct DescriptorBufferInfo;
101 struct DescriptorImageInfo;
102 struct DescriptorPoolCreateInfo;
103 struct DescriptorPoolSize;
104 struct DescriptorSetAllocateInfo;
105 struct DescriptorSetLayoutBinding;
106 struct DescriptorSetLayoutCreateInfo;
107 struct WriteDescriptorSet;
108 struct AttachmentDescription;
109 struct AttachmentReference;
110 struct FramebufferCreateInfo;
111 struct RenderPassCreateInfo;
112 struct SubpassDependency;
113 struct SubpassDescription;
114 struct CommandPoolCreateInfo;
115 struct CommandBufferAllocateInfo;
116 struct CommandBufferBeginInfo;
117 struct CommandBufferInheritanceInfo;
118 struct BufferCopy;
119 struct BufferImageCopy;
120 struct ClearAttachment;
121 union ClearColorValue;
122 struct ClearDepthStencilValue;
123 struct ClearRect;
124 union ClearValue;
125 struct ImageBlit;
126 struct ImageCopy;
127 struct ImageResolve;
128 struct ImageSubresourceLayers;
129 struct RenderPassBeginInfo;
130
131 //=== VK_VERSION_1_1 ===
132 struct PhysicalDeviceSubgroupProperties;
133 struct BindBufferMemoryInfo;
134 using BindBufferMemoryInfoKHR = BindBufferMemoryInfo;
135 struct BindImageMemoryInfo;
136 using BindImageMemoryInfoKHR = BindImageMemoryInfo;
137 struct PhysicalDevice16BitStorageFeatures;
138 using PhysicalDevice16BitStorageFeaturesKHR = PhysicalDevice16BitStorageFeatures;
139 struct MemoryDedicatedRequirements;
140 using MemoryDedicatedRequirementsKHR = MemoryDedicatedRequirements;
141 struct MemoryDedicatedAllocateInfo;
142 using MemoryDedicatedAllocateInfoKHR = MemoryDedicatedAllocateInfo;
143 struct MemoryAllocateFlagsInfo;
144 using MemoryAllocateFlagsInfoKHR = MemoryAllocateFlagsInfo;
145 struct DeviceGroupRenderPassBeginInfo;
146 using DeviceGroupRenderPassBeginInfoKHR = DeviceGroupRenderPassBeginInfo;
147 struct DeviceGroupCommandBufferBeginInfo;
148 using DeviceGroupCommandBufferBeginInfoKHR = DeviceGroupCommandBufferBeginInfo;
149 struct DeviceGroupSubmitInfo;
150 using DeviceGroupSubmitInfoKHR = DeviceGroupSubmitInfo;
151 struct DeviceGroupBindSparseInfo;
152 using DeviceGroupBindSparseInfoKHR = DeviceGroupBindSparseInfo;
153 struct BindBufferMemoryDeviceGroupInfo;
154 using BindBufferMemoryDeviceGroupInfoKHR = BindBufferMemoryDeviceGroupInfo;
155 struct BindImageMemoryDeviceGroupInfo;
156 using BindImageMemoryDeviceGroupInfoKHR = BindImageMemoryDeviceGroupInfo;
157 struct PhysicalDeviceGroupProperties;
158 using PhysicalDeviceGroupPropertiesKHR = PhysicalDeviceGroupProperties;
159 struct DeviceGroupDeviceCreateInfo;
160 using DeviceGroupDeviceCreateInfoKHR = DeviceGroupDeviceCreateInfo;
161 struct BufferMemoryRequirementsInfo2;
162 using BufferMemoryRequirementsInfo2KHR = BufferMemoryRequirementsInfo2;
163 struct ImageMemoryRequirementsInfo2;
164 using ImageMemoryRequirementsInfo2KHR = ImageMemoryRequirementsInfo2;
165 struct ImageSparseMemoryRequirementsInfo2;
166 using ImageSparseMemoryRequirementsInfo2KHR = ImageSparseMemoryRequirementsInfo2;
167 struct MemoryRequirements2;
168 using MemoryRequirements2KHR = MemoryRequirements2;
169 struct SparseImageMemoryRequirements2;
170 using SparseImageMemoryRequirements2KHR = SparseImageMemoryRequirements2;
171 struct PhysicalDeviceFeatures2;
172 using PhysicalDeviceFeatures2KHR = PhysicalDeviceFeatures2;
173 struct PhysicalDeviceProperties2;
174 using PhysicalDeviceProperties2KHR = PhysicalDeviceProperties2;
175 struct FormatProperties2;
176 using FormatProperties2KHR = FormatProperties2;
177 struct ImageFormatProperties2;
178 using ImageFormatProperties2KHR = ImageFormatProperties2;
179 struct PhysicalDeviceImageFormatInfo2;
180 using PhysicalDeviceImageFormatInfo2KHR = PhysicalDeviceImageFormatInfo2;
181 struct QueueFamilyProperties2;
182 using QueueFamilyProperties2KHR = QueueFamilyProperties2;
183 struct PhysicalDeviceMemoryProperties2;
184 using PhysicalDeviceMemoryProperties2KHR = PhysicalDeviceMemoryProperties2;
185 struct SparseImageFormatProperties2;
186 using SparseImageFormatProperties2KHR = SparseImageFormatProperties2;
187 struct PhysicalDeviceSparseImageFormatInfo2;
188 using PhysicalDeviceSparseImageFormatInfo2KHR = PhysicalDeviceSparseImageFormatInfo2;
189 struct PhysicalDevicePointClippingProperties;
190 using PhysicalDevicePointClippingPropertiesKHR = PhysicalDevicePointClippingProperties;
191 struct RenderPassInputAttachmentAspectCreateInfo;
192 using RenderPassInputAttachmentAspectCreateInfoKHR = RenderPassInputAttachmentAspectCreateInfo;
193 struct InputAttachmentAspectReference;
194 using InputAttachmentAspectReferenceKHR = InputAttachmentAspectReference;
195 struct ImageViewUsageCreateInfo;
196 using ImageViewUsageCreateInfoKHR = ImageViewUsageCreateInfo;
197 struct PipelineTessellationDomainOriginStateCreateInfo;
198 using PipelineTessellationDomainOriginStateCreateInfoKHR = PipelineTessellationDomainOriginStateCreateInfo;
199 struct RenderPassMultiviewCreateInfo;
200 using RenderPassMultiviewCreateInfoKHR = RenderPassMultiviewCreateInfo;
201 struct PhysicalDeviceMultiviewFeatures;
202 using PhysicalDeviceMultiviewFeaturesKHR = PhysicalDeviceMultiviewFeatures;
203 struct PhysicalDeviceMultiviewProperties;
204 using PhysicalDeviceMultiviewPropertiesKHR = PhysicalDeviceMultiviewProperties;
205 struct PhysicalDeviceVariablePointersFeatures;
206 using PhysicalDeviceVariablePointerFeatures = PhysicalDeviceVariablePointersFeatures;
207 using PhysicalDeviceVariablePointerFeaturesKHR = PhysicalDeviceVariablePointersFeatures;
208 using PhysicalDeviceVariablePointersFeaturesKHR = PhysicalDeviceVariablePointersFeatures;
209 struct PhysicalDeviceProtectedMemoryFeatures;
210 struct PhysicalDeviceProtectedMemoryProperties;
211 struct DeviceQueueInfo2;
212 struct ProtectedSubmitInfo;
213 struct SamplerYcbcrConversionCreateInfo;
214 using SamplerYcbcrConversionCreateInfoKHR = SamplerYcbcrConversionCreateInfo;
215 struct SamplerYcbcrConversionInfo;
216 using SamplerYcbcrConversionInfoKHR = SamplerYcbcrConversionInfo;
217 struct BindImagePlaneMemoryInfo;
218 using BindImagePlaneMemoryInfoKHR = BindImagePlaneMemoryInfo;
219 struct ImagePlaneMemoryRequirementsInfo;
220 using ImagePlaneMemoryRequirementsInfoKHR = ImagePlaneMemoryRequirementsInfo;
221 struct PhysicalDeviceSamplerYcbcrConversionFeatures;
222 using PhysicalDeviceSamplerYcbcrConversionFeaturesKHR = PhysicalDeviceSamplerYcbcrConversionFeatures;
223 struct SamplerYcbcrConversionImageFormatProperties;
224 using SamplerYcbcrConversionImageFormatPropertiesKHR = SamplerYcbcrConversionImageFormatProperties;
225 struct DescriptorUpdateTemplateEntry;
226 using DescriptorUpdateTemplateEntryKHR = DescriptorUpdateTemplateEntry;
227 struct DescriptorUpdateTemplateCreateInfo;
228 using DescriptorUpdateTemplateCreateInfoKHR = DescriptorUpdateTemplateCreateInfo;
229 struct ExternalMemoryProperties;
230 using ExternalMemoryPropertiesKHR = ExternalMemoryProperties;
231 struct PhysicalDeviceExternalImageFormatInfo;
232 using PhysicalDeviceExternalImageFormatInfoKHR = PhysicalDeviceExternalImageFormatInfo;
233 struct ExternalImageFormatProperties;
234 using ExternalImageFormatPropertiesKHR = ExternalImageFormatProperties;
235 struct PhysicalDeviceExternalBufferInfo;
236 using PhysicalDeviceExternalBufferInfoKHR = PhysicalDeviceExternalBufferInfo;
237 struct ExternalBufferProperties;
238 using ExternalBufferPropertiesKHR = ExternalBufferProperties;
239 struct PhysicalDeviceIDProperties;
240 using PhysicalDeviceIDPropertiesKHR = PhysicalDeviceIDProperties;
241 struct ExternalMemoryImageCreateInfo;
242 using ExternalMemoryImageCreateInfoKHR = ExternalMemoryImageCreateInfo;
243 struct ExternalMemoryBufferCreateInfo;
244 using ExternalMemoryBufferCreateInfoKHR = ExternalMemoryBufferCreateInfo;
245 struct ExportMemoryAllocateInfo;
246 using ExportMemoryAllocateInfoKHR = ExportMemoryAllocateInfo;
247 struct PhysicalDeviceExternalFenceInfo;
248 using PhysicalDeviceExternalFenceInfoKHR = PhysicalDeviceExternalFenceInfo;
249 struct ExternalFenceProperties;
250 using ExternalFencePropertiesKHR = ExternalFenceProperties;
251 struct ExportFenceCreateInfo;
252 using ExportFenceCreateInfoKHR = ExportFenceCreateInfo;
253 struct ExportSemaphoreCreateInfo;
254 using ExportSemaphoreCreateInfoKHR = ExportSemaphoreCreateInfo;
255 struct PhysicalDeviceExternalSemaphoreInfo;
256 using PhysicalDeviceExternalSemaphoreInfoKHR = PhysicalDeviceExternalSemaphoreInfo;
257 struct ExternalSemaphoreProperties;
258 using ExternalSemaphorePropertiesKHR = ExternalSemaphoreProperties;
259 struct PhysicalDeviceMaintenance3Properties;
260 using PhysicalDeviceMaintenance3PropertiesKHR = PhysicalDeviceMaintenance3Properties;
261 struct DescriptorSetLayoutSupport;
262 using DescriptorSetLayoutSupportKHR = DescriptorSetLayoutSupport;
263 struct PhysicalDeviceShaderDrawParametersFeatures;
264 using PhysicalDeviceShaderDrawParameterFeatures = PhysicalDeviceShaderDrawParametersFeatures;
265
266 //=== VK_VERSION_1_2 ===
267 struct PhysicalDeviceVulkan11Features;
268 struct PhysicalDeviceVulkan11Properties;
269 struct PhysicalDeviceVulkan12Features;
270 struct PhysicalDeviceVulkan12Properties;
271 struct ImageFormatListCreateInfo;
272 using ImageFormatListCreateInfoKHR = ImageFormatListCreateInfo;
273 struct RenderPassCreateInfo2;
274 using RenderPassCreateInfo2KHR = RenderPassCreateInfo2;
275 struct AttachmentDescription2;
276 using AttachmentDescription2KHR = AttachmentDescription2;
277 struct AttachmentReference2;
278 using AttachmentReference2KHR = AttachmentReference2;
279 struct SubpassDescription2;
280 using SubpassDescription2KHR = SubpassDescription2;
281 struct SubpassDependency2;
282 using SubpassDependency2KHR = SubpassDependency2;
283 struct SubpassBeginInfo;
284 using SubpassBeginInfoKHR = SubpassBeginInfo;
285 struct SubpassEndInfo;
286 using SubpassEndInfoKHR = SubpassEndInfo;
287 struct PhysicalDevice8BitStorageFeatures;
288 using PhysicalDevice8BitStorageFeaturesKHR = PhysicalDevice8BitStorageFeatures;
289 struct ConformanceVersion;
290 using ConformanceVersionKHR = ConformanceVersion;
291 struct PhysicalDeviceDriverProperties;
292 using PhysicalDeviceDriverPropertiesKHR = PhysicalDeviceDriverProperties;
293 struct PhysicalDeviceShaderAtomicInt64Features;
294 using PhysicalDeviceShaderAtomicInt64FeaturesKHR = PhysicalDeviceShaderAtomicInt64Features;
295 struct PhysicalDeviceShaderFloat16Int8Features;
296 using PhysicalDeviceFloat16Int8FeaturesKHR = PhysicalDeviceShaderFloat16Int8Features;
297 using PhysicalDeviceShaderFloat16Int8FeaturesKHR = PhysicalDeviceShaderFloat16Int8Features;
298 struct PhysicalDeviceFloatControlsProperties;
299 using PhysicalDeviceFloatControlsPropertiesKHR = PhysicalDeviceFloatControlsProperties;
300 struct DescriptorSetLayoutBindingFlagsCreateInfo;
301 using DescriptorSetLayoutBindingFlagsCreateInfoEXT = DescriptorSetLayoutBindingFlagsCreateInfo;
302 struct PhysicalDeviceDescriptorIndexingFeatures;
303 using PhysicalDeviceDescriptorIndexingFeaturesEXT = PhysicalDeviceDescriptorIndexingFeatures;
304 struct PhysicalDeviceDescriptorIndexingProperties;
305 using PhysicalDeviceDescriptorIndexingPropertiesEXT = PhysicalDeviceDescriptorIndexingProperties;
306 struct DescriptorSetVariableDescriptorCountAllocateInfo;
307 using DescriptorSetVariableDescriptorCountAllocateInfoEXT = DescriptorSetVariableDescriptorCountAllocateInfo;
308 struct DescriptorSetVariableDescriptorCountLayoutSupport;
309 using DescriptorSetVariableDescriptorCountLayoutSupportEXT = DescriptorSetVariableDescriptorCountLayoutSupport;
310 struct SubpassDescriptionDepthStencilResolve;
311 using SubpassDescriptionDepthStencilResolveKHR = SubpassDescriptionDepthStencilResolve;
312 struct PhysicalDeviceDepthStencilResolveProperties;
313 using PhysicalDeviceDepthStencilResolvePropertiesKHR = PhysicalDeviceDepthStencilResolveProperties;
314 struct PhysicalDeviceScalarBlockLayoutFeatures;
315 using PhysicalDeviceScalarBlockLayoutFeaturesEXT = PhysicalDeviceScalarBlockLayoutFeatures;
316 struct ImageStencilUsageCreateInfo;
317 using ImageStencilUsageCreateInfoEXT = ImageStencilUsageCreateInfo;
318 struct SamplerReductionModeCreateInfo;
319 using SamplerReductionModeCreateInfoEXT = SamplerReductionModeCreateInfo;
320 struct PhysicalDeviceSamplerFilterMinmaxProperties;
321 using PhysicalDeviceSamplerFilterMinmaxPropertiesEXT = PhysicalDeviceSamplerFilterMinmaxProperties;
322 struct PhysicalDeviceVulkanMemoryModelFeatures;
323 using PhysicalDeviceVulkanMemoryModelFeaturesKHR = PhysicalDeviceVulkanMemoryModelFeatures;
324 struct PhysicalDeviceImagelessFramebufferFeatures;
325 using PhysicalDeviceImagelessFramebufferFeaturesKHR = PhysicalDeviceImagelessFramebufferFeatures;
326 struct FramebufferAttachmentsCreateInfo;
327 using FramebufferAttachmentsCreateInfoKHR = FramebufferAttachmentsCreateInfo;
328 struct FramebufferAttachmentImageInfo;
329 using FramebufferAttachmentImageInfoKHR = FramebufferAttachmentImageInfo;
330 struct RenderPassAttachmentBeginInfo;
331 using RenderPassAttachmentBeginInfoKHR = RenderPassAttachmentBeginInfo;
332 struct PhysicalDeviceUniformBufferStandardLayoutFeatures;
333 using PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR = PhysicalDeviceUniformBufferStandardLayoutFeatures;
334 struct PhysicalDeviceShaderSubgroupExtendedTypesFeatures;
335 using PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR = PhysicalDeviceShaderSubgroupExtendedTypesFeatures;
336 struct PhysicalDeviceSeparateDepthStencilLayoutsFeatures;
337 using PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR = PhysicalDeviceSeparateDepthStencilLayoutsFeatures;
338 struct AttachmentReferenceStencilLayout;
339 using AttachmentReferenceStencilLayoutKHR = AttachmentReferenceStencilLayout;
340 struct AttachmentDescriptionStencilLayout;
341 using AttachmentDescriptionStencilLayoutKHR = AttachmentDescriptionStencilLayout;
342 struct PhysicalDeviceHostQueryResetFeatures;
343 using PhysicalDeviceHostQueryResetFeaturesEXT = PhysicalDeviceHostQueryResetFeatures;
344 struct PhysicalDeviceTimelineSemaphoreFeatures;
345 using PhysicalDeviceTimelineSemaphoreFeaturesKHR = PhysicalDeviceTimelineSemaphoreFeatures;
346 struct PhysicalDeviceTimelineSemaphoreProperties;
347 using PhysicalDeviceTimelineSemaphorePropertiesKHR = PhysicalDeviceTimelineSemaphoreProperties;
348 struct SemaphoreTypeCreateInfo;
349 using SemaphoreTypeCreateInfoKHR = SemaphoreTypeCreateInfo;
350 struct TimelineSemaphoreSubmitInfo;
351 using TimelineSemaphoreSubmitInfoKHR = TimelineSemaphoreSubmitInfo;
352 struct SemaphoreWaitInfo;
353 using SemaphoreWaitInfoKHR = SemaphoreWaitInfo;
354 struct SemaphoreSignalInfo;
355 using SemaphoreSignalInfoKHR = SemaphoreSignalInfo;
356 struct PhysicalDeviceBufferDeviceAddressFeatures;
357 using PhysicalDeviceBufferDeviceAddressFeaturesKHR = PhysicalDeviceBufferDeviceAddressFeatures;
358 struct BufferDeviceAddressInfo;
359 using BufferDeviceAddressInfoEXT = BufferDeviceAddressInfo;
360 using BufferDeviceAddressInfoKHR = BufferDeviceAddressInfo;
361 struct BufferOpaqueCaptureAddressCreateInfo;
362 using BufferOpaqueCaptureAddressCreateInfoKHR = BufferOpaqueCaptureAddressCreateInfo;
363 struct MemoryOpaqueCaptureAddressAllocateInfo;
364 using MemoryOpaqueCaptureAddressAllocateInfoKHR = MemoryOpaqueCaptureAddressAllocateInfo;
365 struct DeviceMemoryOpaqueCaptureAddressInfo;
366 using DeviceMemoryOpaqueCaptureAddressInfoKHR = DeviceMemoryOpaqueCaptureAddressInfo;
367
368 //=== VK_VERSION_1_3 ===
369 struct PhysicalDeviceVulkan13Features;
370 struct PhysicalDeviceVulkan13Properties;
371 struct PipelineCreationFeedbackCreateInfo;
372 using PipelineCreationFeedbackCreateInfoEXT = PipelineCreationFeedbackCreateInfo;
373 struct PipelineCreationFeedback;
374 using PipelineCreationFeedbackEXT = PipelineCreationFeedback;
375 struct PhysicalDeviceShaderTerminateInvocationFeatures;
376 using PhysicalDeviceShaderTerminateInvocationFeaturesKHR = PhysicalDeviceShaderTerminateInvocationFeatures;
377 struct PhysicalDeviceToolProperties;
378 using PhysicalDeviceToolPropertiesEXT = PhysicalDeviceToolProperties;
379 struct PhysicalDeviceShaderDemoteToHelperInvocationFeatures;
380 using PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT = PhysicalDeviceShaderDemoteToHelperInvocationFeatures;
381 struct PhysicalDevicePrivateDataFeatures;
382 using PhysicalDevicePrivateDataFeaturesEXT = PhysicalDevicePrivateDataFeatures;
383 struct DevicePrivateDataCreateInfo;
384 using DevicePrivateDataCreateInfoEXT = DevicePrivateDataCreateInfo;
385 struct PrivateDataSlotCreateInfo;
386 using PrivateDataSlotCreateInfoEXT = PrivateDataSlotCreateInfo;
387 struct PhysicalDevicePipelineCreationCacheControlFeatures;
388 using PhysicalDevicePipelineCreationCacheControlFeaturesEXT = PhysicalDevicePipelineCreationCacheControlFeatures;
389 struct MemoryBarrier2;
390 using MemoryBarrier2KHR = MemoryBarrier2;
391 struct BufferMemoryBarrier2;
392 using BufferMemoryBarrier2KHR = BufferMemoryBarrier2;
393 struct ImageMemoryBarrier2;
394 using ImageMemoryBarrier2KHR = ImageMemoryBarrier2;
395 struct DependencyInfo;
396 using DependencyInfoKHR = DependencyInfo;
397 struct SubmitInfo2;
398 using SubmitInfo2KHR = SubmitInfo2;
399 struct SemaphoreSubmitInfo;
400 using SemaphoreSubmitInfoKHR = SemaphoreSubmitInfo;
401 struct CommandBufferSubmitInfo;
402 using CommandBufferSubmitInfoKHR = CommandBufferSubmitInfo;
403 struct PhysicalDeviceSynchronization2Features;
404 using PhysicalDeviceSynchronization2FeaturesKHR = PhysicalDeviceSynchronization2Features;
405 struct PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures;
406 using PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR = PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures;
407 struct PhysicalDeviceImageRobustnessFeatures;
408 using PhysicalDeviceImageRobustnessFeaturesEXT = PhysicalDeviceImageRobustnessFeatures;
409 struct CopyBufferInfo2;
410 using CopyBufferInfo2KHR = CopyBufferInfo2;
411 struct CopyImageInfo2;
412 using CopyImageInfo2KHR = CopyImageInfo2;
413 struct CopyBufferToImageInfo2;
414 using CopyBufferToImageInfo2KHR = CopyBufferToImageInfo2;
415 struct CopyImageToBufferInfo2;
416 using CopyImageToBufferInfo2KHR = CopyImageToBufferInfo2;
417 struct BlitImageInfo2;
418 using BlitImageInfo2KHR = BlitImageInfo2;
419 struct ResolveImageInfo2;
420 using ResolveImageInfo2KHR = ResolveImageInfo2;
421 struct BufferCopy2;
422 using BufferCopy2KHR = BufferCopy2;
423 struct ImageCopy2;
424 using ImageCopy2KHR = ImageCopy2;
425 struct ImageBlit2;
426 using ImageBlit2KHR = ImageBlit2;
427 struct BufferImageCopy2;
428 using BufferImageCopy2KHR = BufferImageCopy2;
429 struct ImageResolve2;
430 using ImageResolve2KHR = ImageResolve2;
431 struct PhysicalDeviceSubgroupSizeControlFeatures;
432 using PhysicalDeviceSubgroupSizeControlFeaturesEXT = PhysicalDeviceSubgroupSizeControlFeatures;
433 struct PhysicalDeviceSubgroupSizeControlProperties;
434 using PhysicalDeviceSubgroupSizeControlPropertiesEXT = PhysicalDeviceSubgroupSizeControlProperties;
435 struct PipelineShaderStageRequiredSubgroupSizeCreateInfo;
436 using PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT = PipelineShaderStageRequiredSubgroupSizeCreateInfo;
437 using ShaderRequiredSubgroupSizeCreateInfoEXT = PipelineShaderStageRequiredSubgroupSizeCreateInfo;
438 struct PhysicalDeviceInlineUniformBlockFeatures;
439 using PhysicalDeviceInlineUniformBlockFeaturesEXT = PhysicalDeviceInlineUniformBlockFeatures;
440 struct PhysicalDeviceInlineUniformBlockProperties;
441 using PhysicalDeviceInlineUniformBlockPropertiesEXT = PhysicalDeviceInlineUniformBlockProperties;
442 struct WriteDescriptorSetInlineUniformBlock;
443 using WriteDescriptorSetInlineUniformBlockEXT = WriteDescriptorSetInlineUniformBlock;
444 struct DescriptorPoolInlineUniformBlockCreateInfo;
445 using DescriptorPoolInlineUniformBlockCreateInfoEXT = DescriptorPoolInlineUniformBlockCreateInfo;
446 struct PhysicalDeviceTextureCompressionASTCHDRFeatures;
447 using PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT = PhysicalDeviceTextureCompressionASTCHDRFeatures;
448 struct RenderingInfo;
449 using RenderingInfoKHR = RenderingInfo;
450 struct RenderingAttachmentInfo;
451 using RenderingAttachmentInfoKHR = RenderingAttachmentInfo;
452 struct PipelineRenderingCreateInfo;
453 using PipelineRenderingCreateInfoKHR = PipelineRenderingCreateInfo;
454 struct PhysicalDeviceDynamicRenderingFeatures;
455 using PhysicalDeviceDynamicRenderingFeaturesKHR = PhysicalDeviceDynamicRenderingFeatures;
456 struct CommandBufferInheritanceRenderingInfo;
457 using CommandBufferInheritanceRenderingInfoKHR = CommandBufferInheritanceRenderingInfo;
458 struct PhysicalDeviceShaderIntegerDotProductFeatures;
459 using PhysicalDeviceShaderIntegerDotProductFeaturesKHR = PhysicalDeviceShaderIntegerDotProductFeatures;
460 struct PhysicalDeviceShaderIntegerDotProductProperties;
461 using PhysicalDeviceShaderIntegerDotProductPropertiesKHR = PhysicalDeviceShaderIntegerDotProductProperties;
462 struct PhysicalDeviceTexelBufferAlignmentProperties;
463 using PhysicalDeviceTexelBufferAlignmentPropertiesEXT = PhysicalDeviceTexelBufferAlignmentProperties;
464 struct FormatProperties3;
465 using FormatProperties3KHR = FormatProperties3;
466 struct PhysicalDeviceMaintenance4Features;
467 using PhysicalDeviceMaintenance4FeaturesKHR = PhysicalDeviceMaintenance4Features;
468 struct PhysicalDeviceMaintenance4Properties;
469 using PhysicalDeviceMaintenance4PropertiesKHR = PhysicalDeviceMaintenance4Properties;
470 struct DeviceBufferMemoryRequirements;
471 using DeviceBufferMemoryRequirementsKHR = DeviceBufferMemoryRequirements;
472 struct DeviceImageMemoryRequirements;
473 using DeviceImageMemoryRequirementsKHR = DeviceImageMemoryRequirements;
474
475 //=== VK_KHR_surface ===
476 struct SurfaceCapabilitiesKHR;
477 struct SurfaceFormatKHR;
478
479 //=== VK_KHR_swapchain ===
480 struct SwapchainCreateInfoKHR;
481 struct PresentInfoKHR;
482 struct ImageSwapchainCreateInfoKHR;
483 struct BindImageMemorySwapchainInfoKHR;
484 struct AcquireNextImageInfoKHR;
485 struct DeviceGroupPresentCapabilitiesKHR;
486 struct DeviceGroupPresentInfoKHR;
487 struct DeviceGroupSwapchainCreateInfoKHR;
488
489 //=== VK_KHR_display ===
490 struct DisplayModeCreateInfoKHR;
491 struct DisplayModeParametersKHR;
492 struct DisplayModePropertiesKHR;
493 struct DisplayPlaneCapabilitiesKHR;
494 struct DisplayPlanePropertiesKHR;
495 struct DisplayPropertiesKHR;
496 struct DisplaySurfaceCreateInfoKHR;
497
498 //=== VK_KHR_display_swapchain ===
499 struct DisplayPresentInfoKHR;
500
501 #if defined( VK_USE_PLATFORM_XLIB_KHR )
502 //=== VK_KHR_xlib_surface ===
503 struct XlibSurfaceCreateInfoKHR;
504 #endif /*VK_USE_PLATFORM_XLIB_KHR*/
505
506 #if defined( VK_USE_PLATFORM_XCB_KHR )
507 //=== VK_KHR_xcb_surface ===
508 struct XcbSurfaceCreateInfoKHR;
509 #endif /*VK_USE_PLATFORM_XCB_KHR*/
510
511 #if defined( VK_USE_PLATFORM_WAYLAND_KHR )
512 //=== VK_KHR_wayland_surface ===
513 struct WaylandSurfaceCreateInfoKHR;
514 #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
515
516 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
517 //=== VK_KHR_android_surface ===
518 struct AndroidSurfaceCreateInfoKHR;
519 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
520
521 #if defined( VK_USE_PLATFORM_WIN32_KHR )
522 //=== VK_KHR_win32_surface ===
523 struct Win32SurfaceCreateInfoKHR;
524 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
525
526 //=== VK_EXT_debug_report ===
527 struct DebugReportCallbackCreateInfoEXT;
528
529 //=== VK_AMD_rasterization_order ===
530 struct PipelineRasterizationStateRasterizationOrderAMD;
531
532 //=== VK_EXT_debug_marker ===
533 struct DebugMarkerObjectNameInfoEXT;
534 struct DebugMarkerObjectTagInfoEXT;
535 struct DebugMarkerMarkerInfoEXT;
536
537 //=== VK_KHR_video_queue ===
538 struct QueueFamilyQueryResultStatusPropertiesKHR;
539 struct QueueFamilyVideoPropertiesKHR;
540 struct VideoProfileInfoKHR;
541 struct VideoProfileListInfoKHR;
542 struct VideoCapabilitiesKHR;
543 struct PhysicalDeviceVideoFormatInfoKHR;
544 struct VideoFormatPropertiesKHR;
545 struct VideoPictureResourceInfoKHR;
546 struct VideoReferenceSlotInfoKHR;
547 struct VideoSessionMemoryRequirementsKHR;
548 struct BindVideoSessionMemoryInfoKHR;
549 struct VideoSessionCreateInfoKHR;
550 struct VideoSessionParametersCreateInfoKHR;
551 struct VideoSessionParametersUpdateInfoKHR;
552 struct VideoBeginCodingInfoKHR;
553 struct VideoEndCodingInfoKHR;
554 struct VideoCodingControlInfoKHR;
555
556 //=== VK_KHR_video_decode_queue ===
557 struct VideoDecodeCapabilitiesKHR;
558 struct VideoDecodeUsageInfoKHR;
559 struct VideoDecodeInfoKHR;
560
561 //=== VK_NV_dedicated_allocation ===
562 struct DedicatedAllocationImageCreateInfoNV;
563 struct DedicatedAllocationBufferCreateInfoNV;
564 struct DedicatedAllocationMemoryAllocateInfoNV;
565
566 //=== VK_EXT_transform_feedback ===
567 struct PhysicalDeviceTransformFeedbackFeaturesEXT;
568 struct PhysicalDeviceTransformFeedbackPropertiesEXT;
569 struct PipelineRasterizationStateStreamCreateInfoEXT;
570
571 //=== VK_NVX_binary_import ===
572 struct CuModuleCreateInfoNVX;
573 struct CuFunctionCreateInfoNVX;
574 struct CuLaunchInfoNVX;
575
576 //=== VK_NVX_image_view_handle ===
577 struct ImageViewHandleInfoNVX;
578 struct ImageViewAddressPropertiesNVX;
579
580 #if defined( VK_ENABLE_BETA_EXTENSIONS )
581 //=== VK_EXT_video_encode_h264 ===
582 struct VideoEncodeH264CapabilitiesEXT;
583 struct VideoEncodeH264QualityLevelPropertiesEXT;
584 struct VideoEncodeH264SessionCreateInfoEXT;
585 struct VideoEncodeH264SessionParametersCreateInfoEXT;
586 struct VideoEncodeH264SessionParametersAddInfoEXT;
587 struct VideoEncodeH264SessionParametersGetInfoEXT;
588 struct VideoEncodeH264SessionParametersFeedbackInfoEXT;
589 struct VideoEncodeH264PictureInfoEXT;
590 struct VideoEncodeH264DpbSlotInfoEXT;
591 struct VideoEncodeH264NaluSliceInfoEXT;
592 struct VideoEncodeH264ProfileInfoEXT;
593 struct VideoEncodeH264RateControlInfoEXT;
594 struct VideoEncodeH264RateControlLayerInfoEXT;
595 struct VideoEncodeH264QpEXT;
596 struct VideoEncodeH264FrameSizeEXT;
597 struct VideoEncodeH264GopRemainingFrameInfoEXT;
598 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
599
600 #if defined( VK_ENABLE_BETA_EXTENSIONS )
601 //=== VK_EXT_video_encode_h265 ===
602 struct VideoEncodeH265CapabilitiesEXT;
603 struct VideoEncodeH265SessionCreateInfoEXT;
604 struct VideoEncodeH265QualityLevelPropertiesEXT;
605 struct VideoEncodeH265SessionParametersCreateInfoEXT;
606 struct VideoEncodeH265SessionParametersAddInfoEXT;
607 struct VideoEncodeH265SessionParametersGetInfoEXT;
608 struct VideoEncodeH265SessionParametersFeedbackInfoEXT;
609 struct VideoEncodeH265PictureInfoEXT;
610 struct VideoEncodeH265DpbSlotInfoEXT;
611 struct VideoEncodeH265NaluSliceSegmentInfoEXT;
612 struct VideoEncodeH265ProfileInfoEXT;
613 struct VideoEncodeH265RateControlInfoEXT;
614 struct VideoEncodeH265RateControlLayerInfoEXT;
615 struct VideoEncodeH265QpEXT;
616 struct VideoEncodeH265FrameSizeEXT;
617 struct VideoEncodeH265GopRemainingFrameInfoEXT;
618 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
619
620 //=== VK_KHR_video_decode_h264 ===
621 struct VideoDecodeH264ProfileInfoKHR;
622 struct VideoDecodeH264CapabilitiesKHR;
623 struct VideoDecodeH264SessionParametersCreateInfoKHR;
624 struct VideoDecodeH264SessionParametersAddInfoKHR;
625 struct VideoDecodeH264PictureInfoKHR;
626 struct VideoDecodeH264DpbSlotInfoKHR;
627
628 //=== VK_AMD_texture_gather_bias_lod ===
629 struct TextureLODGatherFormatPropertiesAMD;
630
631 //=== VK_AMD_shader_info ===
632 struct ShaderResourceUsageAMD;
633 struct ShaderStatisticsInfoAMD;
634
635 //=== VK_KHR_dynamic_rendering ===
636 struct RenderingFragmentShadingRateAttachmentInfoKHR;
637 struct RenderingFragmentDensityMapAttachmentInfoEXT;
638 struct AttachmentSampleCountInfoAMD;
639 using AttachmentSampleCountInfoNV = AttachmentSampleCountInfoAMD;
640 struct MultiviewPerViewAttributesInfoNVX;
641
642 #if defined( VK_USE_PLATFORM_GGP )
643 //=== VK_GGP_stream_descriptor_surface ===
644 struct StreamDescriptorSurfaceCreateInfoGGP;
645 #endif /*VK_USE_PLATFORM_GGP*/
646
647 //=== VK_NV_corner_sampled_image ===
648 struct PhysicalDeviceCornerSampledImageFeaturesNV;
649
650 //=== VK_NV_external_memory_capabilities ===
651 struct ExternalImageFormatPropertiesNV;
652
653 //=== VK_NV_external_memory ===
654 struct ExternalMemoryImageCreateInfoNV;
655 struct ExportMemoryAllocateInfoNV;
656
657 #if defined( VK_USE_PLATFORM_WIN32_KHR )
658 //=== VK_NV_external_memory_win32 ===
659 struct ImportMemoryWin32HandleInfoNV;
660 struct ExportMemoryWin32HandleInfoNV;
661 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
662
663 #if defined( VK_USE_PLATFORM_WIN32_KHR )
664 //=== VK_NV_win32_keyed_mutex ===
665 struct Win32KeyedMutexAcquireReleaseInfoNV;
666 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
667
668 //=== VK_EXT_validation_flags ===
669 struct ValidationFlagsEXT;
670
671 #if defined( VK_USE_PLATFORM_VI_NN )
672 //=== VK_NN_vi_surface ===
673 struct ViSurfaceCreateInfoNN;
674 #endif /*VK_USE_PLATFORM_VI_NN*/
675
676 //=== VK_EXT_astc_decode_mode ===
677 struct ImageViewASTCDecodeModeEXT;
678 struct PhysicalDeviceASTCDecodeFeaturesEXT;
679
680 //=== VK_EXT_pipeline_robustness ===
681 struct PhysicalDevicePipelineRobustnessFeaturesEXT;
682 struct PhysicalDevicePipelineRobustnessPropertiesEXT;
683 struct PipelineRobustnessCreateInfoEXT;
684
685 #if defined( VK_USE_PLATFORM_WIN32_KHR )
686 //=== VK_KHR_external_memory_win32 ===
687 struct ImportMemoryWin32HandleInfoKHR;
688 struct ExportMemoryWin32HandleInfoKHR;
689 struct MemoryWin32HandlePropertiesKHR;
690 struct MemoryGetWin32HandleInfoKHR;
691 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
692
693 //=== VK_KHR_external_memory_fd ===
694 struct ImportMemoryFdInfoKHR;
695 struct MemoryFdPropertiesKHR;
696 struct MemoryGetFdInfoKHR;
697
698 #if defined( VK_USE_PLATFORM_WIN32_KHR )
699 //=== VK_KHR_win32_keyed_mutex ===
700 struct Win32KeyedMutexAcquireReleaseInfoKHR;
701 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
702
703 #if defined( VK_USE_PLATFORM_WIN32_KHR )
704 //=== VK_KHR_external_semaphore_win32 ===
705 struct ImportSemaphoreWin32HandleInfoKHR;
706 struct ExportSemaphoreWin32HandleInfoKHR;
707 struct D3D12FenceSubmitInfoKHR;
708 struct SemaphoreGetWin32HandleInfoKHR;
709 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
710
711 //=== VK_KHR_external_semaphore_fd ===
712 struct ImportSemaphoreFdInfoKHR;
713 struct SemaphoreGetFdInfoKHR;
714
715 //=== VK_KHR_push_descriptor ===
716 struct PhysicalDevicePushDescriptorPropertiesKHR;
717
718 //=== VK_EXT_conditional_rendering ===
719 struct ConditionalRenderingBeginInfoEXT;
720 struct PhysicalDeviceConditionalRenderingFeaturesEXT;
721 struct CommandBufferInheritanceConditionalRenderingInfoEXT;
722
723 //=== VK_KHR_incremental_present ===
724 struct PresentRegionsKHR;
725 struct PresentRegionKHR;
726 struct RectLayerKHR;
727
728 //=== VK_NV_clip_space_w_scaling ===
729 struct ViewportWScalingNV;
730 struct PipelineViewportWScalingStateCreateInfoNV;
731
732 //=== VK_EXT_display_surface_counter ===
733 struct SurfaceCapabilities2EXT;
734
735 //=== VK_EXT_display_control ===
736 struct DisplayPowerInfoEXT;
737 struct DeviceEventInfoEXT;
738 struct DisplayEventInfoEXT;
739 struct SwapchainCounterCreateInfoEXT;
740
741 //=== VK_GOOGLE_display_timing ===
742 struct RefreshCycleDurationGOOGLE;
743 struct PastPresentationTimingGOOGLE;
744 struct PresentTimesInfoGOOGLE;
745 struct PresentTimeGOOGLE;
746
747 //=== VK_NVX_multiview_per_view_attributes ===
748 struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX;
749
750 //=== VK_NV_viewport_swizzle ===
751 struct ViewportSwizzleNV;
752 struct PipelineViewportSwizzleStateCreateInfoNV;
753
754 //=== VK_EXT_discard_rectangles ===
755 struct PhysicalDeviceDiscardRectanglePropertiesEXT;
756 struct PipelineDiscardRectangleStateCreateInfoEXT;
757
758 //=== VK_EXT_conservative_rasterization ===
759 struct PhysicalDeviceConservativeRasterizationPropertiesEXT;
760 struct PipelineRasterizationConservativeStateCreateInfoEXT;
761
762 //=== VK_EXT_depth_clip_enable ===
763 struct PhysicalDeviceDepthClipEnableFeaturesEXT;
764 struct PipelineRasterizationDepthClipStateCreateInfoEXT;
765
766 //=== VK_EXT_hdr_metadata ===
767 struct HdrMetadataEXT;
768 struct XYColorEXT;
769
770 //=== VK_KHR_shared_presentable_image ===
771 struct SharedPresentSurfaceCapabilitiesKHR;
772
773 #if defined( VK_USE_PLATFORM_WIN32_KHR )
774 //=== VK_KHR_external_fence_win32 ===
775 struct ImportFenceWin32HandleInfoKHR;
776 struct ExportFenceWin32HandleInfoKHR;
777 struct FenceGetWin32HandleInfoKHR;
778 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
779
780 //=== VK_KHR_external_fence_fd ===
781 struct ImportFenceFdInfoKHR;
782 struct FenceGetFdInfoKHR;
783
784 //=== VK_KHR_performance_query ===
785 struct PhysicalDevicePerformanceQueryFeaturesKHR;
786 struct PhysicalDevicePerformanceQueryPropertiesKHR;
787 struct PerformanceCounterKHR;
788 struct PerformanceCounterDescriptionKHR;
789 struct QueryPoolPerformanceCreateInfoKHR;
790 union PerformanceCounterResultKHR;
791 struct AcquireProfilingLockInfoKHR;
792 struct PerformanceQuerySubmitInfoKHR;
793
794 //=== VK_KHR_get_surface_capabilities2 ===
795 struct PhysicalDeviceSurfaceInfo2KHR;
796 struct SurfaceCapabilities2KHR;
797 struct SurfaceFormat2KHR;
798
799 //=== VK_KHR_get_display_properties2 ===
800 struct DisplayProperties2KHR;
801 struct DisplayPlaneProperties2KHR;
802 struct DisplayModeProperties2KHR;
803 struct DisplayPlaneInfo2KHR;
804 struct DisplayPlaneCapabilities2KHR;
805
806 #if defined( VK_USE_PLATFORM_IOS_MVK )
807 //=== VK_MVK_ios_surface ===
808 struct IOSSurfaceCreateInfoMVK;
809 #endif /*VK_USE_PLATFORM_IOS_MVK*/
810
811 #if defined( VK_USE_PLATFORM_MACOS_MVK )
812 //=== VK_MVK_macos_surface ===
813 struct MacOSSurfaceCreateInfoMVK;
814 #endif /*VK_USE_PLATFORM_MACOS_MVK*/
815
816 //=== VK_EXT_debug_utils ===
817 struct DebugUtilsLabelEXT;
818 struct DebugUtilsMessengerCallbackDataEXT;
819 struct DebugUtilsMessengerCreateInfoEXT;
820 struct DebugUtilsObjectNameInfoEXT;
821 struct DebugUtilsObjectTagInfoEXT;
822
823 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
824 //=== VK_ANDROID_external_memory_android_hardware_buffer ===
825 struct AndroidHardwareBufferUsageANDROID;
826 struct AndroidHardwareBufferPropertiesANDROID;
827 struct AndroidHardwareBufferFormatPropertiesANDROID;
828 struct ImportAndroidHardwareBufferInfoANDROID;
829 struct MemoryGetAndroidHardwareBufferInfoANDROID;
830 struct ExternalFormatANDROID;
831 struct AndroidHardwareBufferFormatProperties2ANDROID;
832 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
833
834 #if defined( VK_ENABLE_BETA_EXTENSIONS )
835 //=== VK_AMDX_shader_enqueue ===
836 struct PhysicalDeviceShaderEnqueueFeaturesAMDX;
837 struct PhysicalDeviceShaderEnqueuePropertiesAMDX;
838 struct ExecutionGraphPipelineScratchSizeAMDX;
839 struct ExecutionGraphPipelineCreateInfoAMDX;
840 struct DispatchGraphInfoAMDX;
841 struct DispatchGraphCountInfoAMDX;
842 struct PipelineShaderStageNodeCreateInfoAMDX;
843 union DeviceOrHostAddressConstAMDX;
844 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
845
846 //=== VK_EXT_sample_locations ===
847 struct SampleLocationEXT;
848 struct SampleLocationsInfoEXT;
849 struct AttachmentSampleLocationsEXT;
850 struct SubpassSampleLocationsEXT;
851 struct RenderPassSampleLocationsBeginInfoEXT;
852 struct PipelineSampleLocationsStateCreateInfoEXT;
853 struct PhysicalDeviceSampleLocationsPropertiesEXT;
854 struct MultisamplePropertiesEXT;
855
856 //=== VK_EXT_blend_operation_advanced ===
857 struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT;
858 struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT;
859 struct PipelineColorBlendAdvancedStateCreateInfoEXT;
860
861 //=== VK_NV_fragment_coverage_to_color ===
862 struct PipelineCoverageToColorStateCreateInfoNV;
863
864 //=== VK_KHR_acceleration_structure ===
865 union DeviceOrHostAddressKHR;
866 union DeviceOrHostAddressConstKHR;
867 struct AccelerationStructureBuildRangeInfoKHR;
868 struct AabbPositionsKHR;
869 using AabbPositionsNV = AabbPositionsKHR;
870 struct AccelerationStructureGeometryTrianglesDataKHR;
871 struct TransformMatrixKHR;
872 using TransformMatrixNV = TransformMatrixKHR;
873 struct AccelerationStructureBuildGeometryInfoKHR;
874 struct AccelerationStructureGeometryAabbsDataKHR;
875 struct AccelerationStructureInstanceKHR;
876 using AccelerationStructureInstanceNV = AccelerationStructureInstanceKHR;
877 struct AccelerationStructureGeometryInstancesDataKHR;
878 union AccelerationStructureGeometryDataKHR;
879 struct AccelerationStructureGeometryKHR;
880 struct AccelerationStructureCreateInfoKHR;
881 struct WriteDescriptorSetAccelerationStructureKHR;
882 struct PhysicalDeviceAccelerationStructureFeaturesKHR;
883 struct PhysicalDeviceAccelerationStructurePropertiesKHR;
884 struct AccelerationStructureDeviceAddressInfoKHR;
885 struct AccelerationStructureVersionInfoKHR;
886 struct CopyAccelerationStructureToMemoryInfoKHR;
887 struct CopyMemoryToAccelerationStructureInfoKHR;
888 struct CopyAccelerationStructureInfoKHR;
889 struct AccelerationStructureBuildSizesInfoKHR;
890
891 //=== VK_KHR_ray_tracing_pipeline ===
892 struct RayTracingShaderGroupCreateInfoKHR;
893 struct RayTracingPipelineCreateInfoKHR;
894 struct PhysicalDeviceRayTracingPipelineFeaturesKHR;
895 struct PhysicalDeviceRayTracingPipelinePropertiesKHR;
896 struct StridedDeviceAddressRegionKHR;
897 struct TraceRaysIndirectCommandKHR;
898 struct RayTracingPipelineInterfaceCreateInfoKHR;
899
900 //=== VK_KHR_ray_query ===
901 struct PhysicalDeviceRayQueryFeaturesKHR;
902
903 //=== VK_NV_framebuffer_mixed_samples ===
904 struct PipelineCoverageModulationStateCreateInfoNV;
905
906 //=== VK_NV_shader_sm_builtins ===
907 struct PhysicalDeviceShaderSMBuiltinsPropertiesNV;
908 struct PhysicalDeviceShaderSMBuiltinsFeaturesNV;
909
910 //=== VK_EXT_image_drm_format_modifier ===
911 struct DrmFormatModifierPropertiesListEXT;
912 struct DrmFormatModifierPropertiesEXT;
913 struct PhysicalDeviceImageDrmFormatModifierInfoEXT;
914 struct ImageDrmFormatModifierListCreateInfoEXT;
915 struct ImageDrmFormatModifierExplicitCreateInfoEXT;
916 struct ImageDrmFormatModifierPropertiesEXT;
917 struct DrmFormatModifierPropertiesList2EXT;
918 struct DrmFormatModifierProperties2EXT;
919
920 //=== VK_EXT_validation_cache ===
921 struct ValidationCacheCreateInfoEXT;
922 struct ShaderModuleValidationCacheCreateInfoEXT;
923
924 #if defined( VK_ENABLE_BETA_EXTENSIONS )
925 //=== VK_KHR_portability_subset ===
926 struct PhysicalDevicePortabilitySubsetFeaturesKHR;
927 struct PhysicalDevicePortabilitySubsetPropertiesKHR;
928 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
929
930 //=== VK_NV_shading_rate_image ===
931 struct ShadingRatePaletteNV;
932 struct PipelineViewportShadingRateImageStateCreateInfoNV;
933 struct PhysicalDeviceShadingRateImageFeaturesNV;
934 struct PhysicalDeviceShadingRateImagePropertiesNV;
935 struct CoarseSampleLocationNV;
936 struct CoarseSampleOrderCustomNV;
937 struct PipelineViewportCoarseSampleOrderStateCreateInfoNV;
938
939 //=== VK_NV_ray_tracing ===
940 struct RayTracingShaderGroupCreateInfoNV;
941 struct RayTracingPipelineCreateInfoNV;
942 struct GeometryTrianglesNV;
943 struct GeometryAABBNV;
944 struct GeometryDataNV;
945 struct GeometryNV;
946 struct AccelerationStructureInfoNV;
947 struct AccelerationStructureCreateInfoNV;
948 struct BindAccelerationStructureMemoryInfoNV;
949 struct WriteDescriptorSetAccelerationStructureNV;
950 struct AccelerationStructureMemoryRequirementsInfoNV;
951 struct PhysicalDeviceRayTracingPropertiesNV;
952
953 //=== VK_NV_representative_fragment_test ===
954 struct PhysicalDeviceRepresentativeFragmentTestFeaturesNV;
955 struct PipelineRepresentativeFragmentTestStateCreateInfoNV;
956
957 //=== VK_EXT_filter_cubic ===
958 struct PhysicalDeviceImageViewImageFormatInfoEXT;
959 struct FilterCubicImageViewImageFormatPropertiesEXT;
960
961 //=== VK_EXT_external_memory_host ===
962 struct ImportMemoryHostPointerInfoEXT;
963 struct MemoryHostPointerPropertiesEXT;
964 struct PhysicalDeviceExternalMemoryHostPropertiesEXT;
965
966 //=== VK_KHR_shader_clock ===
967 struct PhysicalDeviceShaderClockFeaturesKHR;
968
969 //=== VK_AMD_pipeline_compiler_control ===
970 struct PipelineCompilerControlCreateInfoAMD;
971
972 //=== VK_EXT_calibrated_timestamps ===
973 struct CalibratedTimestampInfoEXT;
974
975 //=== VK_AMD_shader_core_properties ===
976 struct PhysicalDeviceShaderCorePropertiesAMD;
977
978 //=== VK_KHR_video_decode_h265 ===
979 struct VideoDecodeH265ProfileInfoKHR;
980 struct VideoDecodeH265CapabilitiesKHR;
981 struct VideoDecodeH265SessionParametersCreateInfoKHR;
982 struct VideoDecodeH265SessionParametersAddInfoKHR;
983 struct VideoDecodeH265PictureInfoKHR;
984 struct VideoDecodeH265DpbSlotInfoKHR;
985
986 //=== VK_KHR_global_priority ===
987 struct DeviceQueueGlobalPriorityCreateInfoKHR;
988 using DeviceQueueGlobalPriorityCreateInfoEXT = DeviceQueueGlobalPriorityCreateInfoKHR;
989 struct PhysicalDeviceGlobalPriorityQueryFeaturesKHR;
990 using PhysicalDeviceGlobalPriorityQueryFeaturesEXT = PhysicalDeviceGlobalPriorityQueryFeaturesKHR;
991 struct QueueFamilyGlobalPriorityPropertiesKHR;
992 using QueueFamilyGlobalPriorityPropertiesEXT = QueueFamilyGlobalPriorityPropertiesKHR;
993
994 //=== VK_AMD_memory_overallocation_behavior ===
995 struct DeviceMemoryOverallocationCreateInfoAMD;
996
997 //=== VK_EXT_vertex_attribute_divisor ===
998 struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT;
999 struct VertexInputBindingDivisorDescriptionEXT;
1000 struct PipelineVertexInputDivisorStateCreateInfoEXT;
1001 struct PhysicalDeviceVertexAttributeDivisorFeaturesEXT;
1002
1003 #if defined( VK_USE_PLATFORM_GGP )
1004 //=== VK_GGP_frame_token ===
1005 struct PresentFrameTokenGGP;
1006 #endif /*VK_USE_PLATFORM_GGP*/
1007
1008 //=== VK_NV_compute_shader_derivatives ===
1009 struct PhysicalDeviceComputeShaderDerivativesFeaturesNV;
1010
1011 //=== VK_NV_mesh_shader ===
1012 struct PhysicalDeviceMeshShaderFeaturesNV;
1013 struct PhysicalDeviceMeshShaderPropertiesNV;
1014 struct DrawMeshTasksIndirectCommandNV;
1015
1016 //=== VK_NV_shader_image_footprint ===
1017 struct PhysicalDeviceShaderImageFootprintFeaturesNV;
1018
1019 //=== VK_NV_scissor_exclusive ===
1020 struct PipelineViewportExclusiveScissorStateCreateInfoNV;
1021 struct PhysicalDeviceExclusiveScissorFeaturesNV;
1022
1023 //=== VK_NV_device_diagnostic_checkpoints ===
1024 struct QueueFamilyCheckpointPropertiesNV;
1025 struct CheckpointDataNV;
1026
1027 //=== VK_INTEL_shader_integer_functions2 ===
1028 struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL;
1029
1030 //=== VK_INTEL_performance_query ===
1031 union PerformanceValueDataINTEL;
1032 struct PerformanceValueINTEL;
1033 struct InitializePerformanceApiInfoINTEL;
1034 struct QueryPoolPerformanceQueryCreateInfoINTEL;
1035 using QueryPoolCreateInfoINTEL = QueryPoolPerformanceQueryCreateInfoINTEL;
1036 struct PerformanceMarkerInfoINTEL;
1037 struct PerformanceStreamMarkerInfoINTEL;
1038 struct PerformanceOverrideInfoINTEL;
1039 struct PerformanceConfigurationAcquireInfoINTEL;
1040
1041 //=== VK_EXT_pci_bus_info ===
1042 struct PhysicalDevicePCIBusInfoPropertiesEXT;
1043
1044 //=== VK_AMD_display_native_hdr ===
1045 struct DisplayNativeHdrSurfaceCapabilitiesAMD;
1046 struct SwapchainDisplayNativeHdrCreateInfoAMD;
1047
1048 #if defined( VK_USE_PLATFORM_FUCHSIA )
1049 //=== VK_FUCHSIA_imagepipe_surface ===
1050 struct ImagePipeSurfaceCreateInfoFUCHSIA;
1051 #endif /*VK_USE_PLATFORM_FUCHSIA*/
1052
1053 #if defined( VK_USE_PLATFORM_METAL_EXT )
1054 //=== VK_EXT_metal_surface ===
1055 struct MetalSurfaceCreateInfoEXT;
1056 #endif /*VK_USE_PLATFORM_METAL_EXT*/
1057
1058 //=== VK_EXT_fragment_density_map ===
1059 struct PhysicalDeviceFragmentDensityMapFeaturesEXT;
1060 struct PhysicalDeviceFragmentDensityMapPropertiesEXT;
1061 struct RenderPassFragmentDensityMapCreateInfoEXT;
1062
1063 //=== VK_KHR_fragment_shading_rate ===
1064 struct FragmentShadingRateAttachmentInfoKHR;
1065 struct PipelineFragmentShadingRateStateCreateInfoKHR;
1066 struct PhysicalDeviceFragmentShadingRateFeaturesKHR;
1067 struct PhysicalDeviceFragmentShadingRatePropertiesKHR;
1068 struct PhysicalDeviceFragmentShadingRateKHR;
1069
1070 //=== VK_AMD_shader_core_properties2 ===
1071 struct PhysicalDeviceShaderCoreProperties2AMD;
1072
1073 //=== VK_AMD_device_coherent_memory ===
1074 struct PhysicalDeviceCoherentMemoryFeaturesAMD;
1075
1076 //=== VK_EXT_shader_image_atomic_int64 ===
1077 struct PhysicalDeviceShaderImageAtomicInt64FeaturesEXT;
1078
1079 //=== VK_EXT_memory_budget ===
1080 struct PhysicalDeviceMemoryBudgetPropertiesEXT;
1081
1082 //=== VK_EXT_memory_priority ===
1083 struct PhysicalDeviceMemoryPriorityFeaturesEXT;
1084 struct MemoryPriorityAllocateInfoEXT;
1085
1086 //=== VK_KHR_surface_protected_capabilities ===
1087 struct SurfaceProtectedCapabilitiesKHR;
1088
1089 //=== VK_NV_dedicated_allocation_image_aliasing ===
1090 struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV;
1091
1092 //=== VK_EXT_buffer_device_address ===
1093 struct PhysicalDeviceBufferDeviceAddressFeaturesEXT;
1094 using PhysicalDeviceBufferAddressFeaturesEXT = PhysicalDeviceBufferDeviceAddressFeaturesEXT;
1095 struct BufferDeviceAddressCreateInfoEXT;
1096
1097 //=== VK_EXT_validation_features ===
1098 struct ValidationFeaturesEXT;
1099
1100 //=== VK_KHR_present_wait ===
1101 struct PhysicalDevicePresentWaitFeaturesKHR;
1102
1103 //=== VK_NV_cooperative_matrix ===
1104 struct CooperativeMatrixPropertiesNV;
1105 struct PhysicalDeviceCooperativeMatrixFeaturesNV;
1106 struct PhysicalDeviceCooperativeMatrixPropertiesNV;
1107
1108 //=== VK_NV_coverage_reduction_mode ===
1109 struct PhysicalDeviceCoverageReductionModeFeaturesNV;
1110 struct PipelineCoverageReductionStateCreateInfoNV;
1111 struct FramebufferMixedSamplesCombinationNV;
1112
1113 //=== VK_EXT_fragment_shader_interlock ===
1114 struct PhysicalDeviceFragmentShaderInterlockFeaturesEXT;
1115
1116 //=== VK_EXT_ycbcr_image_arrays ===
1117 struct PhysicalDeviceYcbcrImageArraysFeaturesEXT;
1118
1119 //=== VK_EXT_provoking_vertex ===
1120 struct PhysicalDeviceProvokingVertexFeaturesEXT;
1121 struct PhysicalDeviceProvokingVertexPropertiesEXT;
1122 struct PipelineRasterizationProvokingVertexStateCreateInfoEXT;
1123
1124 #if defined( VK_USE_PLATFORM_WIN32_KHR )
1125 //=== VK_EXT_full_screen_exclusive ===
1126 struct SurfaceFullScreenExclusiveInfoEXT;
1127 struct SurfaceCapabilitiesFullScreenExclusiveEXT;
1128 struct SurfaceFullScreenExclusiveWin32InfoEXT;
1129 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
1130
1131 //=== VK_EXT_headless_surface ===
1132 struct HeadlessSurfaceCreateInfoEXT;
1133
1134 //=== VK_EXT_line_rasterization ===
1135 struct PhysicalDeviceLineRasterizationFeaturesEXT;
1136 struct PhysicalDeviceLineRasterizationPropertiesEXT;
1137 struct PipelineRasterizationLineStateCreateInfoEXT;
1138
1139 //=== VK_EXT_shader_atomic_float ===
1140 struct PhysicalDeviceShaderAtomicFloatFeaturesEXT;
1141
1142 //=== VK_EXT_index_type_uint8 ===
1143 struct PhysicalDeviceIndexTypeUint8FeaturesEXT;
1144
1145 //=== VK_EXT_extended_dynamic_state ===
1146 struct PhysicalDeviceExtendedDynamicStateFeaturesEXT;
1147
1148 //=== VK_KHR_pipeline_executable_properties ===
1149 struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHR;
1150 struct PipelineInfoKHR;
1151 using PipelineInfoEXT = PipelineInfoKHR;
1152 struct PipelineExecutablePropertiesKHR;
1153 struct PipelineExecutableInfoKHR;
1154 union PipelineExecutableStatisticValueKHR;
1155 struct PipelineExecutableStatisticKHR;
1156 struct PipelineExecutableInternalRepresentationKHR;
1157
1158 //=== VK_EXT_host_image_copy ===
1159 struct PhysicalDeviceHostImageCopyFeaturesEXT;
1160 struct PhysicalDeviceHostImageCopyPropertiesEXT;
1161 struct MemoryToImageCopyEXT;
1162 struct ImageToMemoryCopyEXT;
1163 struct CopyMemoryToImageInfoEXT;
1164 struct CopyImageToMemoryInfoEXT;
1165 struct CopyImageToImageInfoEXT;
1166 struct HostImageLayoutTransitionInfoEXT;
1167 struct SubresourceHostMemcpySizeEXT;
1168 struct HostImageCopyDevicePerformanceQueryEXT;
1169
1170 //=== VK_KHR_map_memory2 ===
1171 struct MemoryMapInfoKHR;
1172 struct MemoryUnmapInfoKHR;
1173
1174 //=== VK_EXT_shader_atomic_float2 ===
1175 struct PhysicalDeviceShaderAtomicFloat2FeaturesEXT;
1176
1177 //=== VK_EXT_surface_maintenance1 ===
1178 struct SurfacePresentModeEXT;
1179 struct SurfacePresentScalingCapabilitiesEXT;
1180 struct SurfacePresentModeCompatibilityEXT;
1181
1182 //=== VK_EXT_swapchain_maintenance1 ===
1183 struct PhysicalDeviceSwapchainMaintenance1FeaturesEXT;
1184 struct SwapchainPresentFenceInfoEXT;
1185 struct SwapchainPresentModesCreateInfoEXT;
1186 struct SwapchainPresentModeInfoEXT;
1187 struct SwapchainPresentScalingCreateInfoEXT;
1188 struct ReleaseSwapchainImagesInfoEXT;
1189
1190 //=== VK_NV_device_generated_commands ===
1191 struct PhysicalDeviceDeviceGeneratedCommandsPropertiesNV;
1192 struct PhysicalDeviceDeviceGeneratedCommandsFeaturesNV;
1193 struct GraphicsShaderGroupCreateInfoNV;
1194 struct GraphicsPipelineShaderGroupsCreateInfoNV;
1195 struct BindShaderGroupIndirectCommandNV;
1196 struct BindIndexBufferIndirectCommandNV;
1197 struct BindVertexBufferIndirectCommandNV;
1198 struct SetStateFlagsIndirectCommandNV;
1199 struct IndirectCommandsStreamNV;
1200 struct IndirectCommandsLayoutTokenNV;
1201 struct IndirectCommandsLayoutCreateInfoNV;
1202 struct GeneratedCommandsInfoNV;
1203 struct GeneratedCommandsMemoryRequirementsInfoNV;
1204
1205 //=== VK_NV_inherited_viewport_scissor ===
1206 struct PhysicalDeviceInheritedViewportScissorFeaturesNV;
1207 struct CommandBufferInheritanceViewportScissorInfoNV;
1208
1209 //=== VK_EXT_texel_buffer_alignment ===
1210 struct PhysicalDeviceTexelBufferAlignmentFeaturesEXT;
1211
1212 //=== VK_QCOM_render_pass_transform ===
1213 struct RenderPassTransformBeginInfoQCOM;
1214 struct CommandBufferInheritanceRenderPassTransformInfoQCOM;
1215
1216 //=== VK_EXT_depth_bias_control ===
1217 struct PhysicalDeviceDepthBiasControlFeaturesEXT;
1218 struct DepthBiasInfoEXT;
1219 struct DepthBiasRepresentationInfoEXT;
1220
1221 //=== VK_EXT_device_memory_report ===
1222 struct PhysicalDeviceDeviceMemoryReportFeaturesEXT;
1223 struct DeviceDeviceMemoryReportCreateInfoEXT;
1224 struct DeviceMemoryReportCallbackDataEXT;
1225
1226 //=== VK_EXT_robustness2 ===
1227 struct PhysicalDeviceRobustness2FeaturesEXT;
1228 struct PhysicalDeviceRobustness2PropertiesEXT;
1229
1230 //=== VK_EXT_custom_border_color ===
1231 struct SamplerCustomBorderColorCreateInfoEXT;
1232 struct PhysicalDeviceCustomBorderColorPropertiesEXT;
1233 struct PhysicalDeviceCustomBorderColorFeaturesEXT;
1234
1235 //=== VK_KHR_pipeline_library ===
1236 struct PipelineLibraryCreateInfoKHR;
1237
1238 //=== VK_NV_present_barrier ===
1239 struct PhysicalDevicePresentBarrierFeaturesNV;
1240 struct SurfaceCapabilitiesPresentBarrierNV;
1241 struct SwapchainPresentBarrierCreateInfoNV;
1242
1243 //=== VK_KHR_present_id ===
1244 struct PresentIdKHR;
1245 struct PhysicalDevicePresentIdFeaturesKHR;
1246
1247 #if defined( VK_ENABLE_BETA_EXTENSIONS )
1248 //=== VK_KHR_video_encode_queue ===
1249 struct VideoEncodeInfoKHR;
1250 struct VideoEncodeCapabilitiesKHR;
1251 struct QueryPoolVideoEncodeFeedbackCreateInfoKHR;
1252 struct VideoEncodeUsageInfoKHR;
1253 struct VideoEncodeRateControlInfoKHR;
1254 struct VideoEncodeRateControlLayerInfoKHR;
1255 struct PhysicalDeviceVideoEncodeQualityLevelInfoKHR;
1256 struct VideoEncodeQualityLevelPropertiesKHR;
1257 struct VideoEncodeQualityLevelInfoKHR;
1258 struct VideoEncodeSessionParametersGetInfoKHR;
1259 struct VideoEncodeSessionParametersFeedbackInfoKHR;
1260 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
1261
1262 //=== VK_NV_device_diagnostics_config ===
1263 struct PhysicalDeviceDiagnosticsConfigFeaturesNV;
1264 struct DeviceDiagnosticsConfigCreateInfoNV;
1265
1266 //=== VK_NV_low_latency ===
1267 struct QueryLowLatencySupportNV;
1268
1269 #if defined( VK_USE_PLATFORM_METAL_EXT )
1270 //=== VK_EXT_metal_objects ===
1271 struct ExportMetalObjectCreateInfoEXT;
1272 struct ExportMetalObjectsInfoEXT;
1273 struct ExportMetalDeviceInfoEXT;
1274 struct ExportMetalCommandQueueInfoEXT;
1275 struct ExportMetalBufferInfoEXT;
1276 struct ImportMetalBufferInfoEXT;
1277 struct ExportMetalTextureInfoEXT;
1278 struct ImportMetalTextureInfoEXT;
1279 struct ExportMetalIOSurfaceInfoEXT;
1280 struct ImportMetalIOSurfaceInfoEXT;
1281 struct ExportMetalSharedEventInfoEXT;
1282 struct ImportMetalSharedEventInfoEXT;
1283 #endif /*VK_USE_PLATFORM_METAL_EXT*/
1284
1285 //=== VK_KHR_synchronization2 ===
1286 struct QueueFamilyCheckpointProperties2NV;
1287 struct CheckpointData2NV;
1288
1289 //=== VK_EXT_descriptor_buffer ===
1290 struct PhysicalDeviceDescriptorBufferPropertiesEXT;
1291 struct PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT;
1292 struct PhysicalDeviceDescriptorBufferFeaturesEXT;
1293 struct DescriptorAddressInfoEXT;
1294 struct DescriptorBufferBindingInfoEXT;
1295 struct DescriptorBufferBindingPushDescriptorBufferHandleEXT;
1296 union DescriptorDataEXT;
1297 struct DescriptorGetInfoEXT;
1298 struct BufferCaptureDescriptorDataInfoEXT;
1299 struct ImageCaptureDescriptorDataInfoEXT;
1300 struct ImageViewCaptureDescriptorDataInfoEXT;
1301 struct SamplerCaptureDescriptorDataInfoEXT;
1302 struct OpaqueCaptureDescriptorDataCreateInfoEXT;
1303 struct AccelerationStructureCaptureDescriptorDataInfoEXT;
1304
1305 //=== VK_EXT_graphics_pipeline_library ===
1306 struct PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT;
1307 struct PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT;
1308 struct GraphicsPipelineLibraryCreateInfoEXT;
1309
1310 //=== VK_AMD_shader_early_and_late_fragment_tests ===
1311 struct PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD;
1312
1313 //=== VK_KHR_fragment_shader_barycentric ===
1314 struct PhysicalDeviceFragmentShaderBarycentricFeaturesKHR;
1315 using PhysicalDeviceFragmentShaderBarycentricFeaturesNV = PhysicalDeviceFragmentShaderBarycentricFeaturesKHR;
1316 struct PhysicalDeviceFragmentShaderBarycentricPropertiesKHR;
1317
1318 //=== VK_KHR_shader_subgroup_uniform_control_flow ===
1319 struct PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR;
1320
1321 //=== VK_NV_fragment_shading_rate_enums ===
1322 struct PhysicalDeviceFragmentShadingRateEnumsFeaturesNV;
1323 struct PhysicalDeviceFragmentShadingRateEnumsPropertiesNV;
1324 struct PipelineFragmentShadingRateEnumStateCreateInfoNV;
1325
1326 //=== VK_NV_ray_tracing_motion_blur ===
1327 struct AccelerationStructureGeometryMotionTrianglesDataNV;
1328 struct AccelerationStructureMotionInfoNV;
1329 struct AccelerationStructureMotionInstanceNV;
1330 union AccelerationStructureMotionInstanceDataNV;
1331 struct AccelerationStructureMatrixMotionInstanceNV;
1332 struct AccelerationStructureSRTMotionInstanceNV;
1333 struct SRTDataNV;
1334 struct PhysicalDeviceRayTracingMotionBlurFeaturesNV;
1335
1336 //=== VK_EXT_mesh_shader ===
1337 struct PhysicalDeviceMeshShaderFeaturesEXT;
1338 struct PhysicalDeviceMeshShaderPropertiesEXT;
1339 struct DrawMeshTasksIndirectCommandEXT;
1340
1341 //=== VK_EXT_ycbcr_2plane_444_formats ===
1342 struct PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT;
1343
1344 //=== VK_EXT_fragment_density_map2 ===
1345 struct PhysicalDeviceFragmentDensityMap2FeaturesEXT;
1346 struct PhysicalDeviceFragmentDensityMap2PropertiesEXT;
1347
1348 //=== VK_QCOM_rotated_copy_commands ===
1349 struct CopyCommandTransformInfoQCOM;
1350
1351 //=== VK_KHR_workgroup_memory_explicit_layout ===
1352 struct PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR;
1353
1354 //=== VK_EXT_image_compression_control ===
1355 struct PhysicalDeviceImageCompressionControlFeaturesEXT;
1356 struct ImageCompressionControlEXT;
1357 struct ImageCompressionPropertiesEXT;
1358
1359 //=== VK_EXT_attachment_feedback_loop_layout ===
1360 struct PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT;
1361
1362 //=== VK_EXT_4444_formats ===
1363 struct PhysicalDevice4444FormatsFeaturesEXT;
1364
1365 //=== VK_EXT_device_fault ===
1366 struct PhysicalDeviceFaultFeaturesEXT;
1367 struct DeviceFaultCountsEXT;
1368 struct DeviceFaultInfoEXT;
1369 struct DeviceFaultAddressInfoEXT;
1370 struct DeviceFaultVendorInfoEXT;
1371 struct DeviceFaultVendorBinaryHeaderVersionOneEXT;
1372
1373 //=== VK_EXT_rgba10x6_formats ===
1374 struct PhysicalDeviceRGBA10X6FormatsFeaturesEXT;
1375
1376 #if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
1377 //=== VK_EXT_directfb_surface ===
1378 struct DirectFBSurfaceCreateInfoEXT;
1379 #endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
1380
1381 //=== VK_EXT_vertex_input_dynamic_state ===
1382 struct PhysicalDeviceVertexInputDynamicStateFeaturesEXT;
1383 struct VertexInputBindingDescription2EXT;
1384 struct VertexInputAttributeDescription2EXT;
1385
1386 //=== VK_EXT_physical_device_drm ===
1387 struct PhysicalDeviceDrmPropertiesEXT;
1388
1389 //=== VK_EXT_device_address_binding_report ===
1390 struct PhysicalDeviceAddressBindingReportFeaturesEXT;
1391 struct DeviceAddressBindingCallbackDataEXT;
1392
1393 //=== VK_EXT_depth_clip_control ===
1394 struct PhysicalDeviceDepthClipControlFeaturesEXT;
1395 struct PipelineViewportDepthClipControlCreateInfoEXT;
1396
1397 //=== VK_EXT_primitive_topology_list_restart ===
1398 struct PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT;
1399
1400 #if defined( VK_USE_PLATFORM_FUCHSIA )
1401 //=== VK_FUCHSIA_external_memory ===
1402 struct ImportMemoryZirconHandleInfoFUCHSIA;
1403 struct MemoryZirconHandlePropertiesFUCHSIA;
1404 struct MemoryGetZirconHandleInfoFUCHSIA;
1405 #endif /*VK_USE_PLATFORM_FUCHSIA*/
1406
1407 #if defined( VK_USE_PLATFORM_FUCHSIA )
1408 //=== VK_FUCHSIA_external_semaphore ===
1409 struct ImportSemaphoreZirconHandleInfoFUCHSIA;
1410 struct SemaphoreGetZirconHandleInfoFUCHSIA;
1411 #endif /*VK_USE_PLATFORM_FUCHSIA*/
1412
1413 #if defined( VK_USE_PLATFORM_FUCHSIA )
1414 //=== VK_FUCHSIA_buffer_collection ===
1415 struct BufferCollectionCreateInfoFUCHSIA;
1416 struct ImportMemoryBufferCollectionFUCHSIA;
1417 struct BufferCollectionImageCreateInfoFUCHSIA;
1418 struct BufferConstraintsInfoFUCHSIA;
1419 struct BufferCollectionBufferCreateInfoFUCHSIA;
1420 struct BufferCollectionPropertiesFUCHSIA;
1421 struct SysmemColorSpaceFUCHSIA;
1422 struct ImageConstraintsInfoFUCHSIA;
1423 struct ImageFormatConstraintsInfoFUCHSIA;
1424 struct BufferCollectionConstraintsInfoFUCHSIA;
1425 #endif /*VK_USE_PLATFORM_FUCHSIA*/
1426
1427 //=== VK_HUAWEI_subpass_shading ===
1428 struct SubpassShadingPipelineCreateInfoHUAWEI;
1429 struct PhysicalDeviceSubpassShadingFeaturesHUAWEI;
1430 struct PhysicalDeviceSubpassShadingPropertiesHUAWEI;
1431
1432 //=== VK_HUAWEI_invocation_mask ===
1433 struct PhysicalDeviceInvocationMaskFeaturesHUAWEI;
1434
1435 //=== VK_NV_external_memory_rdma ===
1436 struct MemoryGetRemoteAddressInfoNV;
1437 struct PhysicalDeviceExternalMemoryRDMAFeaturesNV;
1438
1439 //=== VK_EXT_pipeline_properties ===
1440 struct PipelinePropertiesIdentifierEXT;
1441 struct PhysicalDevicePipelinePropertiesFeaturesEXT;
1442
1443 //=== VK_EXT_frame_boundary ===
1444 struct PhysicalDeviceFrameBoundaryFeaturesEXT;
1445 struct FrameBoundaryEXT;
1446
1447 //=== VK_EXT_multisampled_render_to_single_sampled ===
1448 struct PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT;
1449 struct SubpassResolvePerformanceQueryEXT;
1450 struct MultisampledRenderToSingleSampledInfoEXT;
1451
1452 //=== VK_EXT_extended_dynamic_state2 ===
1453 struct PhysicalDeviceExtendedDynamicState2FeaturesEXT;
1454
1455 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
1456 //=== VK_QNX_screen_surface ===
1457 struct ScreenSurfaceCreateInfoQNX;
1458 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
1459
1460 //=== VK_EXT_color_write_enable ===
1461 struct PhysicalDeviceColorWriteEnableFeaturesEXT;
1462 struct PipelineColorWriteCreateInfoEXT;
1463
1464 //=== VK_EXT_primitives_generated_query ===
1465 struct PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT;
1466
1467 //=== VK_KHR_ray_tracing_maintenance1 ===
1468 struct PhysicalDeviceRayTracingMaintenance1FeaturesKHR;
1469 struct TraceRaysIndirectCommand2KHR;
1470
1471 //=== VK_EXT_image_view_min_lod ===
1472 struct PhysicalDeviceImageViewMinLodFeaturesEXT;
1473 struct ImageViewMinLodCreateInfoEXT;
1474
1475 //=== VK_EXT_multi_draw ===
1476 struct PhysicalDeviceMultiDrawFeaturesEXT;
1477 struct PhysicalDeviceMultiDrawPropertiesEXT;
1478 struct MultiDrawInfoEXT;
1479 struct MultiDrawIndexedInfoEXT;
1480
1481 //=== VK_EXT_image_2d_view_of_3d ===
1482 struct PhysicalDeviceImage2DViewOf3DFeaturesEXT;
1483
1484 //=== VK_EXT_shader_tile_image ===
1485 struct PhysicalDeviceShaderTileImageFeaturesEXT;
1486 struct PhysicalDeviceShaderTileImagePropertiesEXT;
1487
1488 //=== VK_EXT_opacity_micromap ===
1489 struct MicromapBuildInfoEXT;
1490 struct MicromapUsageEXT;
1491 struct MicromapCreateInfoEXT;
1492 struct PhysicalDeviceOpacityMicromapFeaturesEXT;
1493 struct PhysicalDeviceOpacityMicromapPropertiesEXT;
1494 struct MicromapVersionInfoEXT;
1495 struct CopyMicromapToMemoryInfoEXT;
1496 struct CopyMemoryToMicromapInfoEXT;
1497 struct CopyMicromapInfoEXT;
1498 struct MicromapBuildSizesInfoEXT;
1499 struct AccelerationStructureTrianglesOpacityMicromapEXT;
1500 struct MicromapTriangleEXT;
1501
1502 #if defined( VK_ENABLE_BETA_EXTENSIONS )
1503 //=== VK_NV_displacement_micromap ===
1504 struct PhysicalDeviceDisplacementMicromapFeaturesNV;
1505 struct PhysicalDeviceDisplacementMicromapPropertiesNV;
1506 struct AccelerationStructureTrianglesDisplacementMicromapNV;
1507 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
1508
1509 //=== VK_HUAWEI_cluster_culling_shader ===
1510 struct PhysicalDeviceClusterCullingShaderFeaturesHUAWEI;
1511 struct PhysicalDeviceClusterCullingShaderPropertiesHUAWEI;
1512
1513 //=== VK_EXT_border_color_swizzle ===
1514 struct PhysicalDeviceBorderColorSwizzleFeaturesEXT;
1515 struct SamplerBorderColorComponentMappingCreateInfoEXT;
1516
1517 //=== VK_EXT_pageable_device_local_memory ===
1518 struct PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT;
1519
1520 //=== VK_ARM_shader_core_properties ===
1521 struct PhysicalDeviceShaderCorePropertiesARM;
1522
1523 //=== VK_EXT_image_sliced_view_of_3d ===
1524 struct PhysicalDeviceImageSlicedViewOf3DFeaturesEXT;
1525 struct ImageViewSlicedCreateInfoEXT;
1526
1527 //=== VK_VALVE_descriptor_set_host_mapping ===
1528 struct PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE;
1529 struct DescriptorSetBindingReferenceVALVE;
1530 struct DescriptorSetLayoutHostMappingInfoVALVE;
1531
1532 //=== VK_EXT_depth_clamp_zero_one ===
1533 struct PhysicalDeviceDepthClampZeroOneFeaturesEXT;
1534
1535 //=== VK_EXT_non_seamless_cube_map ===
1536 struct PhysicalDeviceNonSeamlessCubeMapFeaturesEXT;
1537
1538 //=== VK_QCOM_fragment_density_map_offset ===
1539 struct PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM;
1540 struct PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM;
1541 struct SubpassFragmentDensityMapOffsetEndInfoQCOM;
1542
1543 //=== VK_NV_copy_memory_indirect ===
1544 struct CopyMemoryIndirectCommandNV;
1545 struct CopyMemoryToImageIndirectCommandNV;
1546 struct PhysicalDeviceCopyMemoryIndirectFeaturesNV;
1547 struct PhysicalDeviceCopyMemoryIndirectPropertiesNV;
1548
1549 //=== VK_NV_memory_decompression ===
1550 struct DecompressMemoryRegionNV;
1551 struct PhysicalDeviceMemoryDecompressionFeaturesNV;
1552 struct PhysicalDeviceMemoryDecompressionPropertiesNV;
1553
1554 //=== VK_NV_device_generated_commands_compute ===
1555 struct PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV;
1556 struct ComputePipelineIndirectBufferInfoNV;
1557 struct PipelineIndirectDeviceAddressInfoNV;
1558 struct BindPipelineIndirectCommandNV;
1559
1560 //=== VK_NV_linear_color_attachment ===
1561 struct PhysicalDeviceLinearColorAttachmentFeaturesNV;
1562
1563 //=== VK_EXT_image_compression_control_swapchain ===
1564 struct PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT;
1565
1566 //=== VK_QCOM_image_processing ===
1567 struct ImageViewSampleWeightCreateInfoQCOM;
1568 struct PhysicalDeviceImageProcessingFeaturesQCOM;
1569 struct PhysicalDeviceImageProcessingPropertiesQCOM;
1570
1571 //=== VK_EXT_nested_command_buffer ===
1572 struct PhysicalDeviceNestedCommandBufferFeaturesEXT;
1573 struct PhysicalDeviceNestedCommandBufferPropertiesEXT;
1574
1575 //=== VK_EXT_external_memory_acquire_unmodified ===
1576 struct ExternalMemoryAcquireUnmodifiedEXT;
1577
1578 //=== VK_EXT_extended_dynamic_state3 ===
1579 struct PhysicalDeviceExtendedDynamicState3FeaturesEXT;
1580 struct PhysicalDeviceExtendedDynamicState3PropertiesEXT;
1581 struct ColorBlendEquationEXT;
1582 struct ColorBlendAdvancedEXT;
1583
1584 //=== VK_EXT_subpass_merge_feedback ===
1585 struct PhysicalDeviceSubpassMergeFeedbackFeaturesEXT;
1586 struct RenderPassCreationControlEXT;
1587 struct RenderPassCreationFeedbackInfoEXT;
1588 struct RenderPassCreationFeedbackCreateInfoEXT;
1589 struct RenderPassSubpassFeedbackInfoEXT;
1590 struct RenderPassSubpassFeedbackCreateInfoEXT;
1591
1592 //=== VK_LUNARG_direct_driver_loading ===
1593 struct DirectDriverLoadingInfoLUNARG;
1594 struct DirectDriverLoadingListLUNARG;
1595
1596 //=== VK_EXT_shader_module_identifier ===
1597 struct PhysicalDeviceShaderModuleIdentifierFeaturesEXT;
1598 struct PhysicalDeviceShaderModuleIdentifierPropertiesEXT;
1599 struct PipelineShaderStageModuleIdentifierCreateInfoEXT;
1600 struct ShaderModuleIdentifierEXT;
1601
1602 //=== VK_EXT_rasterization_order_attachment_access ===
1603 struct PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT;
1604 using PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM = PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT;
1605
1606 //=== VK_NV_optical_flow ===
1607 struct PhysicalDeviceOpticalFlowFeaturesNV;
1608 struct PhysicalDeviceOpticalFlowPropertiesNV;
1609 struct OpticalFlowImageFormatInfoNV;
1610 struct OpticalFlowImageFormatPropertiesNV;
1611 struct OpticalFlowSessionCreateInfoNV;
1612 struct OpticalFlowSessionCreatePrivateDataInfoNV;
1613 struct OpticalFlowExecuteInfoNV;
1614
1615 //=== VK_EXT_legacy_dithering ===
1616 struct PhysicalDeviceLegacyDitheringFeaturesEXT;
1617
1618 //=== VK_EXT_pipeline_protected_access ===
1619 struct PhysicalDevicePipelineProtectedAccessFeaturesEXT;
1620
1621 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
1622 //=== VK_ANDROID_external_format_resolve ===
1623 struct PhysicalDeviceExternalFormatResolveFeaturesANDROID;
1624 struct PhysicalDeviceExternalFormatResolvePropertiesANDROID;
1625 struct AndroidHardwareBufferFormatResolvePropertiesANDROID;
1626 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
1627
1628 //=== VK_KHR_maintenance5 ===
1629 struct PhysicalDeviceMaintenance5FeaturesKHR;
1630 struct PhysicalDeviceMaintenance5PropertiesKHR;
1631 struct RenderingAreaInfoKHR;
1632 struct DeviceImageSubresourceInfoKHR;
1633 struct ImageSubresource2KHR;
1634 using ImageSubresource2EXT = ImageSubresource2KHR;
1635 struct SubresourceLayout2KHR;
1636 using SubresourceLayout2EXT = SubresourceLayout2KHR;
1637 struct PipelineCreateFlags2CreateInfoKHR;
1638 struct BufferUsageFlags2CreateInfoKHR;
1639
1640 //=== VK_KHR_ray_tracing_position_fetch ===
1641 struct PhysicalDeviceRayTracingPositionFetchFeaturesKHR;
1642
1643 //=== VK_EXT_shader_object ===
1644 struct PhysicalDeviceShaderObjectFeaturesEXT;
1645 struct PhysicalDeviceShaderObjectPropertiesEXT;
1646 struct ShaderCreateInfoEXT;
1647
1648 //=== VK_QCOM_tile_properties ===
1649 struct PhysicalDeviceTilePropertiesFeaturesQCOM;
1650 struct TilePropertiesQCOM;
1651
1652 //=== VK_SEC_amigo_profiling ===
1653 struct PhysicalDeviceAmigoProfilingFeaturesSEC;
1654 struct AmigoProfilingSubmitInfoSEC;
1655
1656 //=== VK_QCOM_multiview_per_view_viewports ===
1657 struct PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM;
1658
1659 //=== VK_NV_ray_tracing_invocation_reorder ===
1660 struct PhysicalDeviceRayTracingInvocationReorderPropertiesNV;
1661 struct PhysicalDeviceRayTracingInvocationReorderFeaturesNV;
1662
1663 //=== VK_NV_extended_sparse_address_space ===
1664 struct PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV;
1665 struct PhysicalDeviceExtendedSparseAddressSpacePropertiesNV;
1666
1667 //=== VK_EXT_mutable_descriptor_type ===
1668 struct PhysicalDeviceMutableDescriptorTypeFeaturesEXT;
1669 using PhysicalDeviceMutableDescriptorTypeFeaturesVALVE = PhysicalDeviceMutableDescriptorTypeFeaturesEXT;
1670 struct MutableDescriptorTypeListEXT;
1671 using MutableDescriptorTypeListVALVE = MutableDescriptorTypeListEXT;
1672 struct MutableDescriptorTypeCreateInfoEXT;
1673 using MutableDescriptorTypeCreateInfoVALVE = MutableDescriptorTypeCreateInfoEXT;
1674
1675 //=== VK_ARM_shader_core_builtins ===
1676 struct PhysicalDeviceShaderCoreBuiltinsFeaturesARM;
1677 struct PhysicalDeviceShaderCoreBuiltinsPropertiesARM;
1678
1679 //=== VK_EXT_pipeline_library_group_handles ===
1680 struct PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT;
1681
1682 //=== VK_EXT_dynamic_rendering_unused_attachments ===
1683 struct PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT;
1684
1685 //=== VK_NV_low_latency2 ===
1686 struct LatencySleepModeInfoNV;
1687 struct LatencySleepInfoNV;
1688 struct SetLatencyMarkerInfoNV;
1689 struct GetLatencyMarkerInfoNV;
1690 struct LatencyTimingsFrameReportNV;
1691 struct LatencySubmissionPresentIdNV;
1692 struct SwapchainLatencyCreateInfoNV;
1693 struct OutOfBandQueueTypeInfoNV;
1694 struct LatencySurfaceCapabilitiesNV;
1695
1696 //=== VK_KHR_cooperative_matrix ===
1697 struct CooperativeMatrixPropertiesKHR;
1698 struct PhysicalDeviceCooperativeMatrixFeaturesKHR;
1699 struct PhysicalDeviceCooperativeMatrixPropertiesKHR;
1700
1701 //=== VK_QCOM_multiview_per_view_render_areas ===
1702 struct PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM;
1703 struct MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM;
1704
1705 //=== VK_QCOM_image_processing2 ===
1706 struct PhysicalDeviceImageProcessing2FeaturesQCOM;
1707 struct PhysicalDeviceImageProcessing2PropertiesQCOM;
1708 struct SamplerBlockMatchWindowCreateInfoQCOM;
1709
1710 //=== VK_QCOM_filter_cubic_weights ===
1711 struct PhysicalDeviceCubicWeightsFeaturesQCOM;
1712 struct SamplerCubicWeightsCreateInfoQCOM;
1713 struct BlitImageCubicWeightsInfoQCOM;
1714
1715 //=== VK_QCOM_ycbcr_degamma ===
1716 struct PhysicalDeviceYcbcrDegammaFeaturesQCOM;
1717 struct SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM;
1718
1719 //=== VK_QCOM_filter_cubic_clamp ===
1720 struct PhysicalDeviceCubicClampFeaturesQCOM;
1721
1722 //=== VK_EXT_attachment_feedback_loop_dynamic_state ===
1723 struct PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT;
1724
1725 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
1726 //=== VK_QNX_external_memory_screen_buffer ===
1727 struct ScreenBufferPropertiesQNX;
1728 struct ScreenBufferFormatPropertiesQNX;
1729 struct ImportScreenBufferInfoQNX;
1730 struct ExternalFormatQNX;
1731 struct PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX;
1732 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
1733
1734 //=== VK_MSFT_layered_driver ===
1735 struct PhysicalDeviceLayeredDriverPropertiesMSFT;
1736
1737 //=== VK_NV_descriptor_pool_overallocation ===
1738 struct PhysicalDeviceDescriptorPoolOverallocationFeaturesNV;
1739
1740
1741
1742 //===================================
1743 //=== HANDLE forward declarations ===
1744 //===================================
1745
1746
1747 //=== VK_VERSION_1_0 ===
1748 class Instance;
1749 class PhysicalDevice;
1750 class Device;
1751 class Queue;
1752 class DeviceMemory;
1753 class Fence;
1754 class Semaphore;
1755 class Event;
1756 class QueryPool;
1757 class Buffer;
1758 class BufferView;
1759 class Image;
1760 class ImageView;
1761 class ShaderModule;
1762 class PipelineCache;
1763 class Pipeline;
1764 class PipelineLayout;
1765 class Sampler;
1766 class DescriptorPool;
1767 class DescriptorSet;
1768 class DescriptorSetLayout;
1769 class Framebuffer;
1770 class RenderPass;
1771 class CommandPool;
1772 class CommandBuffer;
1773
1774 //=== VK_VERSION_1_1 ===
1775 class SamplerYcbcrConversion;
1776 class DescriptorUpdateTemplate;
1777
1778 //=== VK_VERSION_1_3 ===
1779 class PrivateDataSlot;
1780
1781 //=== VK_KHR_surface ===
1782 class SurfaceKHR;
1783
1784 //=== VK_KHR_swapchain ===
1785 class SwapchainKHR;
1786
1787 //=== VK_KHR_display ===
1788 class DisplayKHR;
1789 class DisplayModeKHR;
1790
1791 //=== VK_EXT_debug_report ===
1792 class DebugReportCallbackEXT;
1793
1794 //=== VK_KHR_video_queue ===
1795 class VideoSessionKHR;
1796 class VideoSessionParametersKHR;
1797
1798 //=== VK_NVX_binary_import ===
1799 class CuModuleNVX;
1800 class CuFunctionNVX;
1801
1802 //=== VK_EXT_debug_utils ===
1803 class DebugUtilsMessengerEXT;
1804
1805 //=== VK_KHR_acceleration_structure ===
1806 class AccelerationStructureKHR;
1807
1808 //=== VK_EXT_validation_cache ===
1809 class ValidationCacheEXT;
1810
1811 //=== VK_NV_ray_tracing ===
1812 class AccelerationStructureNV;
1813
1814 //=== VK_INTEL_performance_query ===
1815 class PerformanceConfigurationINTEL;
1816
1817 //=== VK_KHR_deferred_host_operations ===
1818 class DeferredOperationKHR;
1819
1820 //=== VK_NV_device_generated_commands ===
1821 class IndirectCommandsLayoutNV;
1822
1823 #if defined( VK_USE_PLATFORM_FUCHSIA )
1824 //=== VK_FUCHSIA_buffer_collection ===
1825 class BufferCollectionFUCHSIA;
1826 #endif /*VK_USE_PLATFORM_FUCHSIA*/
1827
1828 //=== VK_EXT_opacity_micromap ===
1829 class MicromapEXT;
1830
1831 //=== VK_NV_optical_flow ===
1832 class OpticalFlowSessionNV;
1833
1834 //=== VK_EXT_shader_object ===
1835 class ShaderEXT;
1836
1837
1838
1839 #ifndef VULKAN_HPP_NO_SMART_HANDLE
1840 //======================
1841 //=== UNIQUE HANDLEs ===
1842 //======================
1843
1844
1845 //=== VK_VERSION_1_0 ===
1846 template <typename Dispatch>
1847 class UniqueHandleTraits<Instance, Dispatch>
1848 {
1849 public:
1850 using deleter = ObjectDestroy<NoParent, Dispatch>;
1851 };
1852 using UniqueInstance = UniqueHandle<Instance, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
1853 template <typename Dispatch>
1854 class UniqueHandleTraits<Device, Dispatch>
1855 {
1856 public:
1857 using deleter = ObjectDestroy<NoParent, Dispatch>;
1858 };
1859 using UniqueDevice = UniqueHandle<Device, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
1860 template <typename Dispatch>
1861 class UniqueHandleTraits<DeviceMemory, Dispatch>
1862 {
1863 public:
1864 using deleter = ObjectFree<Device, Dispatch>;
1865 };
1866 using UniqueDeviceMemory = UniqueHandle<DeviceMemory, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
1867 template <typename Dispatch>
1868 class UniqueHandleTraits<Fence, Dispatch>
1869 {
1870 public:
1871 using deleter = ObjectDestroy<Device, Dispatch>;
1872 };
1873 using UniqueFence = UniqueHandle<Fence, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
1874 template <typename Dispatch>
1875 class UniqueHandleTraits<Semaphore, Dispatch>
1876 {
1877 public:
1878 using deleter = ObjectDestroy<Device, Dispatch>;
1879 };
1880 using UniqueSemaphore = UniqueHandle<Semaphore, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
1881 template <typename Dispatch>
1882 class UniqueHandleTraits<Event, Dispatch>
1883 {
1884 public:
1885 using deleter = ObjectDestroy<Device, Dispatch>;
1886 };
1887 using UniqueEvent = UniqueHandle<Event, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
1888 template <typename Dispatch>
1889 class UniqueHandleTraits<QueryPool, Dispatch>
1890 {
1891 public:
1892 using deleter = ObjectDestroy<Device, Dispatch>;
1893 };
1894 using UniqueQueryPool = UniqueHandle<QueryPool, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
1895 template <typename Dispatch>
1896 class UniqueHandleTraits<Buffer, Dispatch>
1897 {
1898 public:
1899 using deleter = ObjectDestroy<Device, Dispatch>;
1900 };
1901 using UniqueBuffer = UniqueHandle<Buffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
1902 template <typename Dispatch>
1903 class UniqueHandleTraits<BufferView, Dispatch>
1904 {
1905 public:
1906 using deleter = ObjectDestroy<Device, Dispatch>;
1907 };
1908 using UniqueBufferView = UniqueHandle<BufferView, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
1909 template <typename Dispatch>
1910 class UniqueHandleTraits<Image, Dispatch>
1911 {
1912 public:
1913 using deleter = ObjectDestroy<Device, Dispatch>;
1914 };
1915 using UniqueImage = UniqueHandle<Image, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
1916 template <typename Dispatch>
1917 class UniqueHandleTraits<ImageView, Dispatch>
1918 {
1919 public:
1920 using deleter = ObjectDestroy<Device, Dispatch>;
1921 };
1922 using UniqueImageView = UniqueHandle<ImageView, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
1923 template <typename Dispatch>
1924 class UniqueHandleTraits<ShaderModule, Dispatch>
1925 {
1926 public:
1927 using deleter = ObjectDestroy<Device, Dispatch>;
1928 };
1929 using UniqueShaderModule = UniqueHandle<ShaderModule, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
1930 template <typename Dispatch>
1931 class UniqueHandleTraits<PipelineCache, Dispatch>
1932 {
1933 public:
1934 using deleter = ObjectDestroy<Device, Dispatch>;
1935 };
1936 using UniquePipelineCache = UniqueHandle<PipelineCache, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
1937 template <typename Dispatch>
1938 class UniqueHandleTraits<Pipeline, Dispatch>
1939 {
1940 public:
1941 using deleter = ObjectDestroy<Device, Dispatch>;
1942 };
1943 using UniquePipeline = UniqueHandle<Pipeline, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
1944 template <typename Dispatch>
1945 class UniqueHandleTraits<PipelineLayout, Dispatch>
1946 {
1947 public:
1948 using deleter = ObjectDestroy<Device, Dispatch>;
1949 };
1950 using UniquePipelineLayout = UniqueHandle<PipelineLayout, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
1951 template <typename Dispatch>
1952 class UniqueHandleTraits<Sampler, Dispatch>
1953 {
1954 public:
1955 using deleter = ObjectDestroy<Device, Dispatch>;
1956 };
1957 using UniqueSampler = UniqueHandle<Sampler, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
1958 template <typename Dispatch>
1959 class UniqueHandleTraits<DescriptorPool, Dispatch>
1960 {
1961 public:
1962 using deleter = ObjectDestroy<Device, Dispatch>;
1963 };
1964 using UniqueDescriptorPool = UniqueHandle<DescriptorPool, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
1965 template <typename Dispatch>
1966 class UniqueHandleTraits<DescriptorSet, Dispatch>
1967 {
1968 public:
1969 using deleter = PoolFree<Device, DescriptorPool, Dispatch>;
1970 };
1971 using UniqueDescriptorSet = UniqueHandle<DescriptorSet, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
1972 template <typename Dispatch>
1973 class UniqueHandleTraits<DescriptorSetLayout, Dispatch>
1974 {
1975 public:
1976 using deleter = ObjectDestroy<Device, Dispatch>;
1977 };
1978 using UniqueDescriptorSetLayout = UniqueHandle<DescriptorSetLayout, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
1979 template <typename Dispatch>
1980 class UniqueHandleTraits<Framebuffer, Dispatch>
1981 {
1982 public:
1983 using deleter = ObjectDestroy<Device, Dispatch>;
1984 };
1985 using UniqueFramebuffer = UniqueHandle<Framebuffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
1986 template <typename Dispatch>
1987 class UniqueHandleTraits<RenderPass, Dispatch>
1988 {
1989 public:
1990 using deleter = ObjectDestroy<Device, Dispatch>;
1991 };
1992 using UniqueRenderPass = UniqueHandle<RenderPass, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
1993 template <typename Dispatch>
1994 class UniqueHandleTraits<CommandPool, Dispatch>
1995 {
1996 public:
1997 using deleter = ObjectDestroy<Device, Dispatch>;
1998 };
1999 using UniqueCommandPool = UniqueHandle<CommandPool, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2000 template <typename Dispatch>
2001 class UniqueHandleTraits<CommandBuffer, Dispatch>
2002 {
2003 public:
2004 using deleter = PoolFree<Device, CommandPool, Dispatch>;
2005 };
2006 using UniqueCommandBuffer = UniqueHandle<CommandBuffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2007
2008 //=== VK_VERSION_1_1 ===
2009 template <typename Dispatch>
2010 class UniqueHandleTraits<SamplerYcbcrConversion, Dispatch>
2011 {
2012 public:
2013 using deleter = ObjectDestroy<Device, Dispatch>;
2014 };
2015 using UniqueSamplerYcbcrConversion = UniqueHandle<SamplerYcbcrConversion, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2016 using UniqueSamplerYcbcrConversionKHR = UniqueHandle<SamplerYcbcrConversion, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>; template <typename Dispatch>
2017 class UniqueHandleTraits<DescriptorUpdateTemplate, Dispatch>
2018 {
2019 public:
2020 using deleter = ObjectDestroy<Device, Dispatch>;
2021 };
2022 using UniqueDescriptorUpdateTemplate = UniqueHandle<DescriptorUpdateTemplate, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2023 using UniqueDescriptorUpdateTemplateKHR = UniqueHandle<DescriptorUpdateTemplate, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2024 //=== VK_VERSION_1_3 ===
2025 template <typename Dispatch>
2026 class UniqueHandleTraits<PrivateDataSlot, Dispatch>
2027 {
2028 public:
2029 using deleter = ObjectDestroy<Device, Dispatch>;
2030 };
2031 using UniquePrivateDataSlot = UniqueHandle<PrivateDataSlot, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2032 using UniquePrivateDataSlotEXT = UniqueHandle<PrivateDataSlot, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2033 //=== VK_KHR_surface ===
2034 template <typename Dispatch>
2035 class UniqueHandleTraits<SurfaceKHR, Dispatch>
2036 {
2037 public:
2038 using deleter = ObjectDestroy<Instance, Dispatch>;
2039 };
2040 using UniqueSurfaceKHR = UniqueHandle<SurfaceKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2041
2042 //=== VK_KHR_swapchain ===
2043 template <typename Dispatch>
2044 class UniqueHandleTraits<SwapchainKHR, Dispatch>
2045 {
2046 public:
2047 using deleter = ObjectDestroy<Device, Dispatch>;
2048 };
2049 using UniqueSwapchainKHR = UniqueHandle<SwapchainKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2050
2051 //=== VK_KHR_display ===
2052 template <typename Dispatch>
2053 class UniqueHandleTraits<DisplayKHR, Dispatch>
2054 {
2055 public:
2056 using deleter = ObjectDestroy<PhysicalDevice, Dispatch>;
2057 };
2058 using UniqueDisplayKHR = UniqueHandle<DisplayKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2059
2060 //=== VK_EXT_debug_report ===
2061 template <typename Dispatch>
2062 class UniqueHandleTraits<DebugReportCallbackEXT, Dispatch>
2063 {
2064 public:
2065 using deleter = ObjectDestroy<Instance, Dispatch>;
2066 };
2067 using UniqueDebugReportCallbackEXT = UniqueHandle<DebugReportCallbackEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2068
2069 //=== VK_KHR_video_queue ===
2070 template <typename Dispatch>
2071 class UniqueHandleTraits<VideoSessionKHR, Dispatch>
2072 {
2073 public:
2074 using deleter = ObjectDestroy<Device, Dispatch>;
2075 };
2076 using UniqueVideoSessionKHR = UniqueHandle<VideoSessionKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2077 template <typename Dispatch>
2078 class UniqueHandleTraits<VideoSessionParametersKHR, Dispatch>
2079 {
2080 public:
2081 using deleter = ObjectDestroy<Device, Dispatch>;
2082 };
2083 using UniqueVideoSessionParametersKHR = UniqueHandle<VideoSessionParametersKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2084
2085 //=== VK_NVX_binary_import ===
2086 template <typename Dispatch>
2087 class UniqueHandleTraits<CuModuleNVX, Dispatch>
2088 {
2089 public:
2090 using deleter = ObjectDestroy<Device, Dispatch>;
2091 };
2092 using UniqueCuModuleNVX = UniqueHandle<CuModuleNVX, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2093 template <typename Dispatch>
2094 class UniqueHandleTraits<CuFunctionNVX, Dispatch>
2095 {
2096 public:
2097 using deleter = ObjectDestroy<Device, Dispatch>;
2098 };
2099 using UniqueCuFunctionNVX = UniqueHandle<CuFunctionNVX, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2100
2101 //=== VK_EXT_debug_utils ===
2102 template <typename Dispatch>
2103 class UniqueHandleTraits<DebugUtilsMessengerEXT, Dispatch>
2104 {
2105 public:
2106 using deleter = ObjectDestroy<Instance, Dispatch>;
2107 };
2108 using UniqueDebugUtilsMessengerEXT = UniqueHandle<DebugUtilsMessengerEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2109
2110 //=== VK_KHR_acceleration_structure ===
2111 template <typename Dispatch>
2112 class UniqueHandleTraits<AccelerationStructureKHR, Dispatch>
2113 {
2114 public:
2115 using deleter = ObjectDestroy<Device, Dispatch>;
2116 };
2117 using UniqueAccelerationStructureKHR = UniqueHandle<AccelerationStructureKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2118
2119 //=== VK_EXT_validation_cache ===
2120 template <typename Dispatch>
2121 class UniqueHandleTraits<ValidationCacheEXT, Dispatch>
2122 {
2123 public:
2124 using deleter = ObjectDestroy<Device, Dispatch>;
2125 };
2126 using UniqueValidationCacheEXT = UniqueHandle<ValidationCacheEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2127
2128 //=== VK_NV_ray_tracing ===
2129 template <typename Dispatch>
2130 class UniqueHandleTraits<AccelerationStructureNV, Dispatch>
2131 {
2132 public:
2133 using deleter = ObjectDestroy<Device, Dispatch>;
2134 };
2135 using UniqueAccelerationStructureNV = UniqueHandle<AccelerationStructureNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2136
2137 //=== VK_INTEL_performance_query ===
2138 template <typename Dispatch>
2139 class UniqueHandleTraits<PerformanceConfigurationINTEL, Dispatch>
2140 {
2141 public:
2142 using deleter = ObjectDestroy<Device, Dispatch>;
2143 };
2144 using UniquePerformanceConfigurationINTEL = UniqueHandle<PerformanceConfigurationINTEL, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2145
2146 //=== VK_KHR_deferred_host_operations ===
2147 template <typename Dispatch>
2148 class UniqueHandleTraits<DeferredOperationKHR, Dispatch>
2149 {
2150 public:
2151 using deleter = ObjectDestroy<Device, Dispatch>;
2152 };
2153 using UniqueDeferredOperationKHR = UniqueHandle<DeferredOperationKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2154
2155 //=== VK_NV_device_generated_commands ===
2156 template <typename Dispatch>
2157 class UniqueHandleTraits<IndirectCommandsLayoutNV, Dispatch>
2158 {
2159 public:
2160 using deleter = ObjectDestroy<Device, Dispatch>;
2161 };
2162 using UniqueIndirectCommandsLayoutNV = UniqueHandle<IndirectCommandsLayoutNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2163
2164 #if defined( VK_USE_PLATFORM_FUCHSIA )
2165 //=== VK_FUCHSIA_buffer_collection ===
2166 template <typename Dispatch>
2167 class UniqueHandleTraits<BufferCollectionFUCHSIA, Dispatch>
2168 {
2169 public:
2170 using deleter = ObjectDestroy<Device, Dispatch>;
2171 };
2172 using UniqueBufferCollectionFUCHSIA = UniqueHandle<BufferCollectionFUCHSIA, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2173 #endif /*VK_USE_PLATFORM_FUCHSIA*/
2174
2175 //=== VK_EXT_opacity_micromap ===
2176 template <typename Dispatch>
2177 class UniqueHandleTraits<MicromapEXT, Dispatch>
2178 {
2179 public:
2180 using deleter = ObjectDestroy<Device, Dispatch>;
2181 };
2182 using UniqueMicromapEXT = UniqueHandle<MicromapEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2183
2184 //=== VK_NV_optical_flow ===
2185 template <typename Dispatch>
2186 class UniqueHandleTraits<OpticalFlowSessionNV, Dispatch>
2187 {
2188 public:
2189 using deleter = ObjectDestroy<Device, Dispatch>;
2190 };
2191 using UniqueOpticalFlowSessionNV = UniqueHandle<OpticalFlowSessionNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2192
2193 //=== VK_EXT_shader_object ===
2194 template <typename Dispatch>
2195 class UniqueHandleTraits<ShaderEXT, Dispatch>
2196 {
2197 public:
2198 using deleter = ObjectDestroy<Device, Dispatch>;
2199 };
2200 using UniqueShaderEXT = UniqueHandle<ShaderEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2201 #endif /*VULKAN_HPP_NO_SMART_HANDLE*/
2202
2203
2204 //===============
2205 //=== HANDLEs ===
2206 //===============
2207
2208 template <typename Type>
2209 struct isVulkanHandleType
2210 {
2211 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = false;
2212 };
2213
2214 class SurfaceKHR
2215 {
2216 public:
2217 using CType = VkSurfaceKHR;
2218 using NativeType = VkSurfaceKHR;
2219
2220 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSurfaceKHR;
2221 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSurfaceKHR;
2222
2223 public:
2224 VULKAN_HPP_CONSTEXPR SurfaceKHR() = default;
SurfaceKHR(std::nullptr_t)2225 VULKAN_HPP_CONSTEXPR SurfaceKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2226 {}
SurfaceKHR(VkSurfaceKHR surfaceKHR)2227 VULKAN_HPP_TYPESAFE_EXPLICIT SurfaceKHR( VkSurfaceKHR surfaceKHR ) VULKAN_HPP_NOEXCEPT
2228 : m_surfaceKHR( surfaceKHR )
2229 {}
2230
2231 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkSurfaceKHR surfaceKHR)2232 SurfaceKHR & operator=(VkSurfaceKHR surfaceKHR) VULKAN_HPP_NOEXCEPT
2233 {
2234 m_surfaceKHR = surfaceKHR;
2235 return *this;
2236 }
2237 #endif
2238
operator =(std::nullptr_t)2239 SurfaceKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2240 {
2241 m_surfaceKHR = {};
2242 return *this;
2243 }
2244
2245 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
2246 auto operator<=>( SurfaceKHR const & ) const = default;
2247 #else
operator ==(SurfaceKHR const & rhs) const2248 bool operator==( SurfaceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
2249 {
2250 return m_surfaceKHR == rhs.m_surfaceKHR;
2251 }
2252
operator !=(SurfaceKHR const & rhs) const2253 bool operator!=(SurfaceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
2254 {
2255 return m_surfaceKHR != rhs.m_surfaceKHR;
2256 }
2257
operator <(SurfaceKHR const & rhs) const2258 bool operator<(SurfaceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
2259 {
2260 return m_surfaceKHR < rhs.m_surfaceKHR;
2261 }
2262 #endif
2263
operator VkSurfaceKHR() const2264 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSurfaceKHR() const VULKAN_HPP_NOEXCEPT
2265 {
2266 return m_surfaceKHR;
2267 }
2268
operator bool() const2269 explicit operator bool() const VULKAN_HPP_NOEXCEPT
2270 {
2271 return m_surfaceKHR != VK_NULL_HANDLE;
2272 }
2273
operator !() const2274 bool operator!() const VULKAN_HPP_NOEXCEPT
2275 {
2276 return m_surfaceKHR == VK_NULL_HANDLE;
2277 }
2278
2279 private:
2280 VkSurfaceKHR m_surfaceKHR = {};
2281 };
2282
2283 template <>
2284 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSurfaceKHR>
2285 {
2286 using Type = VULKAN_HPP_NAMESPACE::SurfaceKHR;
2287 };
2288
2289
2290 template <>
2291 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSurfaceKHR>
2292 {
2293 using Type = VULKAN_HPP_NAMESPACE::SurfaceKHR;
2294 };
2295
2296
2297 template <>
2298 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::SurfaceKHR>
2299 {
2300 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2301 };
2302
2303 class DebugReportCallbackEXT
2304 {
2305 public:
2306 using CType = VkDebugReportCallbackEXT;
2307 using NativeType = VkDebugReportCallbackEXT;
2308
2309 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDebugReportCallbackEXT;
2310 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDebugReportCallbackEXT;
2311
2312 public:
2313 VULKAN_HPP_CONSTEXPR DebugReportCallbackEXT() = default;
DebugReportCallbackEXT(std::nullptr_t)2314 VULKAN_HPP_CONSTEXPR DebugReportCallbackEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2315 {}
DebugReportCallbackEXT(VkDebugReportCallbackEXT debugReportCallbackEXT)2316 VULKAN_HPP_TYPESAFE_EXPLICIT DebugReportCallbackEXT( VkDebugReportCallbackEXT debugReportCallbackEXT ) VULKAN_HPP_NOEXCEPT
2317 : m_debugReportCallbackEXT( debugReportCallbackEXT )
2318 {}
2319
2320 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkDebugReportCallbackEXT debugReportCallbackEXT)2321 DebugReportCallbackEXT & operator=(VkDebugReportCallbackEXT debugReportCallbackEXT) VULKAN_HPP_NOEXCEPT
2322 {
2323 m_debugReportCallbackEXT = debugReportCallbackEXT;
2324 return *this;
2325 }
2326 #endif
2327
operator =(std::nullptr_t)2328 DebugReportCallbackEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2329 {
2330 m_debugReportCallbackEXT = {};
2331 return *this;
2332 }
2333
2334 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
2335 auto operator<=>( DebugReportCallbackEXT const & ) const = default;
2336 #else
operator ==(DebugReportCallbackEXT const & rhs) const2337 bool operator==( DebugReportCallbackEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
2338 {
2339 return m_debugReportCallbackEXT == rhs.m_debugReportCallbackEXT;
2340 }
2341
operator !=(DebugReportCallbackEXT const & rhs) const2342 bool operator!=(DebugReportCallbackEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
2343 {
2344 return m_debugReportCallbackEXT != rhs.m_debugReportCallbackEXT;
2345 }
2346
operator <(DebugReportCallbackEXT const & rhs) const2347 bool operator<(DebugReportCallbackEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
2348 {
2349 return m_debugReportCallbackEXT < rhs.m_debugReportCallbackEXT;
2350 }
2351 #endif
2352
operator VkDebugReportCallbackEXT() const2353 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDebugReportCallbackEXT() const VULKAN_HPP_NOEXCEPT
2354 {
2355 return m_debugReportCallbackEXT;
2356 }
2357
operator bool() const2358 explicit operator bool() const VULKAN_HPP_NOEXCEPT
2359 {
2360 return m_debugReportCallbackEXT != VK_NULL_HANDLE;
2361 }
2362
operator !() const2363 bool operator!() const VULKAN_HPP_NOEXCEPT
2364 {
2365 return m_debugReportCallbackEXT == VK_NULL_HANDLE;
2366 }
2367
2368 private:
2369 VkDebugReportCallbackEXT m_debugReportCallbackEXT = {};
2370 };
2371
2372 template <>
2373 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDebugReportCallbackEXT>
2374 {
2375 using Type = VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT;
2376 };
2377
2378
2379 template <>
2380 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDebugReportCallbackEXT>
2381 {
2382 using Type = VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT;
2383 };
2384
2385
2386 template <>
2387 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT>
2388 {
2389 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2390 };
2391
2392 class DebugUtilsMessengerEXT
2393 {
2394 public:
2395 using CType = VkDebugUtilsMessengerEXT;
2396 using NativeType = VkDebugUtilsMessengerEXT;
2397
2398 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDebugUtilsMessengerEXT;
2399 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
2400
2401 public:
2402 VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT() = default;
DebugUtilsMessengerEXT(std::nullptr_t)2403 VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2404 {}
DebugUtilsMessengerEXT(VkDebugUtilsMessengerEXT debugUtilsMessengerEXT)2405 VULKAN_HPP_TYPESAFE_EXPLICIT DebugUtilsMessengerEXT( VkDebugUtilsMessengerEXT debugUtilsMessengerEXT ) VULKAN_HPP_NOEXCEPT
2406 : m_debugUtilsMessengerEXT( debugUtilsMessengerEXT )
2407 {}
2408
2409 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkDebugUtilsMessengerEXT debugUtilsMessengerEXT)2410 DebugUtilsMessengerEXT & operator=(VkDebugUtilsMessengerEXT debugUtilsMessengerEXT) VULKAN_HPP_NOEXCEPT
2411 {
2412 m_debugUtilsMessengerEXT = debugUtilsMessengerEXT;
2413 return *this;
2414 }
2415 #endif
2416
operator =(std::nullptr_t)2417 DebugUtilsMessengerEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2418 {
2419 m_debugUtilsMessengerEXT = {};
2420 return *this;
2421 }
2422
2423 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
2424 auto operator<=>( DebugUtilsMessengerEXT const & ) const = default;
2425 #else
operator ==(DebugUtilsMessengerEXT const & rhs) const2426 bool operator==( DebugUtilsMessengerEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
2427 {
2428 return m_debugUtilsMessengerEXT == rhs.m_debugUtilsMessengerEXT;
2429 }
2430
operator !=(DebugUtilsMessengerEXT const & rhs) const2431 bool operator!=(DebugUtilsMessengerEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
2432 {
2433 return m_debugUtilsMessengerEXT != rhs.m_debugUtilsMessengerEXT;
2434 }
2435
operator <(DebugUtilsMessengerEXT const & rhs) const2436 bool operator<(DebugUtilsMessengerEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
2437 {
2438 return m_debugUtilsMessengerEXT < rhs.m_debugUtilsMessengerEXT;
2439 }
2440 #endif
2441
operator VkDebugUtilsMessengerEXT() const2442 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDebugUtilsMessengerEXT() const VULKAN_HPP_NOEXCEPT
2443 {
2444 return m_debugUtilsMessengerEXT;
2445 }
2446
operator bool() const2447 explicit operator bool() const VULKAN_HPP_NOEXCEPT
2448 {
2449 return m_debugUtilsMessengerEXT != VK_NULL_HANDLE;
2450 }
2451
operator !() const2452 bool operator!() const VULKAN_HPP_NOEXCEPT
2453 {
2454 return m_debugUtilsMessengerEXT == VK_NULL_HANDLE;
2455 }
2456
2457 private:
2458 VkDebugUtilsMessengerEXT m_debugUtilsMessengerEXT = {};
2459 };
2460
2461 template <>
2462 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDebugUtilsMessengerEXT>
2463 {
2464 using Type = VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT;
2465 };
2466
2467
2468
2469 template <>
2470 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT>
2471 {
2472 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2473 };
2474
2475 class DisplayKHR
2476 {
2477 public:
2478 using CType = VkDisplayKHR;
2479 using NativeType = VkDisplayKHR;
2480
2481 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDisplayKHR;
2482 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayKHR;
2483
2484 public:
2485 VULKAN_HPP_CONSTEXPR DisplayKHR() = default;
DisplayKHR(std::nullptr_t)2486 VULKAN_HPP_CONSTEXPR DisplayKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2487 {}
DisplayKHR(VkDisplayKHR displayKHR)2488 VULKAN_HPP_TYPESAFE_EXPLICIT DisplayKHR( VkDisplayKHR displayKHR ) VULKAN_HPP_NOEXCEPT
2489 : m_displayKHR( displayKHR )
2490 {}
2491
2492 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkDisplayKHR displayKHR)2493 DisplayKHR & operator=(VkDisplayKHR displayKHR) VULKAN_HPP_NOEXCEPT
2494 {
2495 m_displayKHR = displayKHR;
2496 return *this;
2497 }
2498 #endif
2499
operator =(std::nullptr_t)2500 DisplayKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2501 {
2502 m_displayKHR = {};
2503 return *this;
2504 }
2505
2506 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
2507 auto operator<=>( DisplayKHR const & ) const = default;
2508 #else
operator ==(DisplayKHR const & rhs) const2509 bool operator==( DisplayKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
2510 {
2511 return m_displayKHR == rhs.m_displayKHR;
2512 }
2513
operator !=(DisplayKHR const & rhs) const2514 bool operator!=(DisplayKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
2515 {
2516 return m_displayKHR != rhs.m_displayKHR;
2517 }
2518
operator <(DisplayKHR const & rhs) const2519 bool operator<(DisplayKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
2520 {
2521 return m_displayKHR < rhs.m_displayKHR;
2522 }
2523 #endif
2524
operator VkDisplayKHR() const2525 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDisplayKHR() const VULKAN_HPP_NOEXCEPT
2526 {
2527 return m_displayKHR;
2528 }
2529
operator bool() const2530 explicit operator bool() const VULKAN_HPP_NOEXCEPT
2531 {
2532 return m_displayKHR != VK_NULL_HANDLE;
2533 }
2534
operator !() const2535 bool operator!() const VULKAN_HPP_NOEXCEPT
2536 {
2537 return m_displayKHR == VK_NULL_HANDLE;
2538 }
2539
2540 private:
2541 VkDisplayKHR m_displayKHR = {};
2542 };
2543
2544 template <>
2545 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDisplayKHR>
2546 {
2547 using Type = VULKAN_HPP_NAMESPACE::DisplayKHR;
2548 };
2549
2550
2551 template <>
2552 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayKHR>
2553 {
2554 using Type = VULKAN_HPP_NAMESPACE::DisplayKHR;
2555 };
2556
2557
2558 template <>
2559 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DisplayKHR>
2560 {
2561 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2562 };
2563
2564 class SwapchainKHR
2565 {
2566 public:
2567 using CType = VkSwapchainKHR;
2568 using NativeType = VkSwapchainKHR;
2569
2570 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSwapchainKHR;
2571 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSwapchainKHR;
2572
2573 public:
2574 VULKAN_HPP_CONSTEXPR SwapchainKHR() = default;
SwapchainKHR(std::nullptr_t)2575 VULKAN_HPP_CONSTEXPR SwapchainKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2576 {}
SwapchainKHR(VkSwapchainKHR swapchainKHR)2577 VULKAN_HPP_TYPESAFE_EXPLICIT SwapchainKHR( VkSwapchainKHR swapchainKHR ) VULKAN_HPP_NOEXCEPT
2578 : m_swapchainKHR( swapchainKHR )
2579 {}
2580
2581 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkSwapchainKHR swapchainKHR)2582 SwapchainKHR & operator=(VkSwapchainKHR swapchainKHR) VULKAN_HPP_NOEXCEPT
2583 {
2584 m_swapchainKHR = swapchainKHR;
2585 return *this;
2586 }
2587 #endif
2588
operator =(std::nullptr_t)2589 SwapchainKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2590 {
2591 m_swapchainKHR = {};
2592 return *this;
2593 }
2594
2595 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
2596 auto operator<=>( SwapchainKHR const & ) const = default;
2597 #else
operator ==(SwapchainKHR const & rhs) const2598 bool operator==( SwapchainKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
2599 {
2600 return m_swapchainKHR == rhs.m_swapchainKHR;
2601 }
2602
operator !=(SwapchainKHR const & rhs) const2603 bool operator!=(SwapchainKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
2604 {
2605 return m_swapchainKHR != rhs.m_swapchainKHR;
2606 }
2607
operator <(SwapchainKHR const & rhs) const2608 bool operator<(SwapchainKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
2609 {
2610 return m_swapchainKHR < rhs.m_swapchainKHR;
2611 }
2612 #endif
2613
operator VkSwapchainKHR() const2614 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSwapchainKHR() const VULKAN_HPP_NOEXCEPT
2615 {
2616 return m_swapchainKHR;
2617 }
2618
operator bool() const2619 explicit operator bool() const VULKAN_HPP_NOEXCEPT
2620 {
2621 return m_swapchainKHR != VK_NULL_HANDLE;
2622 }
2623
operator !() const2624 bool operator!() const VULKAN_HPP_NOEXCEPT
2625 {
2626 return m_swapchainKHR == VK_NULL_HANDLE;
2627 }
2628
2629 private:
2630 VkSwapchainKHR m_swapchainKHR = {};
2631 };
2632
2633 template <>
2634 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSwapchainKHR>
2635 {
2636 using Type = VULKAN_HPP_NAMESPACE::SwapchainKHR;
2637 };
2638
2639
2640 template <>
2641 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSwapchainKHR>
2642 {
2643 using Type = VULKAN_HPP_NAMESPACE::SwapchainKHR;
2644 };
2645
2646
2647 template <>
2648 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::SwapchainKHR>
2649 {
2650 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2651 };
2652
2653 class Semaphore
2654 {
2655 public:
2656 using CType = VkSemaphore;
2657 using NativeType = VkSemaphore;
2658
2659 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSemaphore;
2660 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSemaphore;
2661
2662 public:
2663 VULKAN_HPP_CONSTEXPR Semaphore() = default;
Semaphore(std::nullptr_t)2664 VULKAN_HPP_CONSTEXPR Semaphore( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2665 {}
Semaphore(VkSemaphore semaphore)2666 VULKAN_HPP_TYPESAFE_EXPLICIT Semaphore( VkSemaphore semaphore ) VULKAN_HPP_NOEXCEPT
2667 : m_semaphore( semaphore )
2668 {}
2669
2670 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkSemaphore semaphore)2671 Semaphore & operator=(VkSemaphore semaphore) VULKAN_HPP_NOEXCEPT
2672 {
2673 m_semaphore = semaphore;
2674 return *this;
2675 }
2676 #endif
2677
operator =(std::nullptr_t)2678 Semaphore & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2679 {
2680 m_semaphore = {};
2681 return *this;
2682 }
2683
2684 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
2685 auto operator<=>( Semaphore const & ) const = default;
2686 #else
operator ==(Semaphore const & rhs) const2687 bool operator==( Semaphore const & rhs ) const VULKAN_HPP_NOEXCEPT
2688 {
2689 return m_semaphore == rhs.m_semaphore;
2690 }
2691
operator !=(Semaphore const & rhs) const2692 bool operator!=(Semaphore const & rhs ) const VULKAN_HPP_NOEXCEPT
2693 {
2694 return m_semaphore != rhs.m_semaphore;
2695 }
2696
operator <(Semaphore const & rhs) const2697 bool operator<(Semaphore const & rhs ) const VULKAN_HPP_NOEXCEPT
2698 {
2699 return m_semaphore < rhs.m_semaphore;
2700 }
2701 #endif
2702
operator VkSemaphore() const2703 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSemaphore() const VULKAN_HPP_NOEXCEPT
2704 {
2705 return m_semaphore;
2706 }
2707
operator bool() const2708 explicit operator bool() const VULKAN_HPP_NOEXCEPT
2709 {
2710 return m_semaphore != VK_NULL_HANDLE;
2711 }
2712
operator !() const2713 bool operator!() const VULKAN_HPP_NOEXCEPT
2714 {
2715 return m_semaphore == VK_NULL_HANDLE;
2716 }
2717
2718 private:
2719 VkSemaphore m_semaphore = {};
2720 };
2721
2722 template <>
2723 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSemaphore>
2724 {
2725 using Type = VULKAN_HPP_NAMESPACE::Semaphore;
2726 };
2727
2728
2729 template <>
2730 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSemaphore>
2731 {
2732 using Type = VULKAN_HPP_NAMESPACE::Semaphore;
2733 };
2734
2735
2736 template <>
2737 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Semaphore>
2738 {
2739 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2740 };
2741
2742 class Fence
2743 {
2744 public:
2745 using CType = VkFence;
2746 using NativeType = VkFence;
2747
2748 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eFence;
2749 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFence;
2750
2751 public:
2752 VULKAN_HPP_CONSTEXPR Fence() = default;
Fence(std::nullptr_t)2753 VULKAN_HPP_CONSTEXPR Fence( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2754 {}
Fence(VkFence fence)2755 VULKAN_HPP_TYPESAFE_EXPLICIT Fence( VkFence fence ) VULKAN_HPP_NOEXCEPT
2756 : m_fence( fence )
2757 {}
2758
2759 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkFence fence)2760 Fence & operator=(VkFence fence) VULKAN_HPP_NOEXCEPT
2761 {
2762 m_fence = fence;
2763 return *this;
2764 }
2765 #endif
2766
operator =(std::nullptr_t)2767 Fence & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2768 {
2769 m_fence = {};
2770 return *this;
2771 }
2772
2773 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
2774 auto operator<=>( Fence const & ) const = default;
2775 #else
operator ==(Fence const & rhs) const2776 bool operator==( Fence const & rhs ) const VULKAN_HPP_NOEXCEPT
2777 {
2778 return m_fence == rhs.m_fence;
2779 }
2780
operator !=(Fence const & rhs) const2781 bool operator!=(Fence const & rhs ) const VULKAN_HPP_NOEXCEPT
2782 {
2783 return m_fence != rhs.m_fence;
2784 }
2785
operator <(Fence const & rhs) const2786 bool operator<(Fence const & rhs ) const VULKAN_HPP_NOEXCEPT
2787 {
2788 return m_fence < rhs.m_fence;
2789 }
2790 #endif
2791
operator VkFence() const2792 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkFence() const VULKAN_HPP_NOEXCEPT
2793 {
2794 return m_fence;
2795 }
2796
operator bool() const2797 explicit operator bool() const VULKAN_HPP_NOEXCEPT
2798 {
2799 return m_fence != VK_NULL_HANDLE;
2800 }
2801
operator !() const2802 bool operator!() const VULKAN_HPP_NOEXCEPT
2803 {
2804 return m_fence == VK_NULL_HANDLE;
2805 }
2806
2807 private:
2808 VkFence m_fence = {};
2809 };
2810
2811 template <>
2812 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eFence>
2813 {
2814 using Type = VULKAN_HPP_NAMESPACE::Fence;
2815 };
2816
2817
2818 template <>
2819 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFence>
2820 {
2821 using Type = VULKAN_HPP_NAMESPACE::Fence;
2822 };
2823
2824
2825 template <>
2826 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Fence>
2827 {
2828 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2829 };
2830
2831 class PerformanceConfigurationINTEL
2832 {
2833 public:
2834 using CType = VkPerformanceConfigurationINTEL;
2835 using NativeType = VkPerformanceConfigurationINTEL;
2836
2837 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePerformanceConfigurationINTEL;
2838 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
2839
2840 public:
2841 VULKAN_HPP_CONSTEXPR PerformanceConfigurationINTEL() = default;
PerformanceConfigurationINTEL(std::nullptr_t)2842 VULKAN_HPP_CONSTEXPR PerformanceConfigurationINTEL( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2843 {}
PerformanceConfigurationINTEL(VkPerformanceConfigurationINTEL performanceConfigurationINTEL)2844 VULKAN_HPP_TYPESAFE_EXPLICIT PerformanceConfigurationINTEL( VkPerformanceConfigurationINTEL performanceConfigurationINTEL ) VULKAN_HPP_NOEXCEPT
2845 : m_performanceConfigurationINTEL( performanceConfigurationINTEL )
2846 {}
2847
2848 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkPerformanceConfigurationINTEL performanceConfigurationINTEL)2849 PerformanceConfigurationINTEL & operator=(VkPerformanceConfigurationINTEL performanceConfigurationINTEL) VULKAN_HPP_NOEXCEPT
2850 {
2851 m_performanceConfigurationINTEL = performanceConfigurationINTEL;
2852 return *this;
2853 }
2854 #endif
2855
operator =(std::nullptr_t)2856 PerformanceConfigurationINTEL & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2857 {
2858 m_performanceConfigurationINTEL = {};
2859 return *this;
2860 }
2861
2862 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
2863 auto operator<=>( PerformanceConfigurationINTEL const & ) const = default;
2864 #else
operator ==(PerformanceConfigurationINTEL const & rhs) const2865 bool operator==( PerformanceConfigurationINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
2866 {
2867 return m_performanceConfigurationINTEL == rhs.m_performanceConfigurationINTEL;
2868 }
2869
operator !=(PerformanceConfigurationINTEL const & rhs) const2870 bool operator!=(PerformanceConfigurationINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
2871 {
2872 return m_performanceConfigurationINTEL != rhs.m_performanceConfigurationINTEL;
2873 }
2874
operator <(PerformanceConfigurationINTEL const & rhs) const2875 bool operator<(PerformanceConfigurationINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
2876 {
2877 return m_performanceConfigurationINTEL < rhs.m_performanceConfigurationINTEL;
2878 }
2879 #endif
2880
operator VkPerformanceConfigurationINTEL() const2881 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPerformanceConfigurationINTEL() const VULKAN_HPP_NOEXCEPT
2882 {
2883 return m_performanceConfigurationINTEL;
2884 }
2885
operator bool() const2886 explicit operator bool() const VULKAN_HPP_NOEXCEPT
2887 {
2888 return m_performanceConfigurationINTEL != VK_NULL_HANDLE;
2889 }
2890
operator !() const2891 bool operator!() const VULKAN_HPP_NOEXCEPT
2892 {
2893 return m_performanceConfigurationINTEL == VK_NULL_HANDLE;
2894 }
2895
2896 private:
2897 VkPerformanceConfigurationINTEL m_performanceConfigurationINTEL = {};
2898 };
2899
2900 template <>
2901 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePerformanceConfigurationINTEL>
2902 {
2903 using Type = VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL;
2904 };
2905
2906
2907
2908 template <>
2909 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL>
2910 {
2911 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2912 };
2913
2914 class QueryPool
2915 {
2916 public:
2917 using CType = VkQueryPool;
2918 using NativeType = VkQueryPool;
2919
2920 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eQueryPool;
2921 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueryPool;
2922
2923 public:
2924 VULKAN_HPP_CONSTEXPR QueryPool() = default;
QueryPool(std::nullptr_t)2925 VULKAN_HPP_CONSTEXPR QueryPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2926 {}
QueryPool(VkQueryPool queryPool)2927 VULKAN_HPP_TYPESAFE_EXPLICIT QueryPool( VkQueryPool queryPool ) VULKAN_HPP_NOEXCEPT
2928 : m_queryPool( queryPool )
2929 {}
2930
2931 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkQueryPool queryPool)2932 QueryPool & operator=(VkQueryPool queryPool) VULKAN_HPP_NOEXCEPT
2933 {
2934 m_queryPool = queryPool;
2935 return *this;
2936 }
2937 #endif
2938
operator =(std::nullptr_t)2939 QueryPool & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2940 {
2941 m_queryPool = {};
2942 return *this;
2943 }
2944
2945 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
2946 auto operator<=>( QueryPool const & ) const = default;
2947 #else
operator ==(QueryPool const & rhs) const2948 bool operator==( QueryPool const & rhs ) const VULKAN_HPP_NOEXCEPT
2949 {
2950 return m_queryPool == rhs.m_queryPool;
2951 }
2952
operator !=(QueryPool const & rhs) const2953 bool operator!=(QueryPool const & rhs ) const VULKAN_HPP_NOEXCEPT
2954 {
2955 return m_queryPool != rhs.m_queryPool;
2956 }
2957
operator <(QueryPool const & rhs) const2958 bool operator<(QueryPool const & rhs ) const VULKAN_HPP_NOEXCEPT
2959 {
2960 return m_queryPool < rhs.m_queryPool;
2961 }
2962 #endif
2963
operator VkQueryPool() const2964 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkQueryPool() const VULKAN_HPP_NOEXCEPT
2965 {
2966 return m_queryPool;
2967 }
2968
operator bool() const2969 explicit operator bool() const VULKAN_HPP_NOEXCEPT
2970 {
2971 return m_queryPool != VK_NULL_HANDLE;
2972 }
2973
operator !() const2974 bool operator!() const VULKAN_HPP_NOEXCEPT
2975 {
2976 return m_queryPool == VK_NULL_HANDLE;
2977 }
2978
2979 private:
2980 VkQueryPool m_queryPool = {};
2981 };
2982
2983 template <>
2984 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eQueryPool>
2985 {
2986 using Type = VULKAN_HPP_NAMESPACE::QueryPool;
2987 };
2988
2989
2990 template <>
2991 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueryPool>
2992 {
2993 using Type = VULKAN_HPP_NAMESPACE::QueryPool;
2994 };
2995
2996
2997 template <>
2998 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::QueryPool>
2999 {
3000 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3001 };
3002
3003 class Buffer
3004 {
3005 public:
3006 using CType = VkBuffer;
3007 using NativeType = VkBuffer;
3008
3009 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eBuffer;
3010 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBuffer;
3011
3012 public:
3013 VULKAN_HPP_CONSTEXPR Buffer() = default;
Buffer(std::nullptr_t)3014 VULKAN_HPP_CONSTEXPR Buffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3015 {}
Buffer(VkBuffer buffer)3016 VULKAN_HPP_TYPESAFE_EXPLICIT Buffer( VkBuffer buffer ) VULKAN_HPP_NOEXCEPT
3017 : m_buffer( buffer )
3018 {}
3019
3020 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkBuffer buffer)3021 Buffer & operator=(VkBuffer buffer) VULKAN_HPP_NOEXCEPT
3022 {
3023 m_buffer = buffer;
3024 return *this;
3025 }
3026 #endif
3027
operator =(std::nullptr_t)3028 Buffer & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3029 {
3030 m_buffer = {};
3031 return *this;
3032 }
3033
3034 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
3035 auto operator<=>( Buffer const & ) const = default;
3036 #else
operator ==(Buffer const & rhs) const3037 bool operator==( Buffer const & rhs ) const VULKAN_HPP_NOEXCEPT
3038 {
3039 return m_buffer == rhs.m_buffer;
3040 }
3041
operator !=(Buffer const & rhs) const3042 bool operator!=(Buffer const & rhs ) const VULKAN_HPP_NOEXCEPT
3043 {
3044 return m_buffer != rhs.m_buffer;
3045 }
3046
operator <(Buffer const & rhs) const3047 bool operator<(Buffer const & rhs ) const VULKAN_HPP_NOEXCEPT
3048 {
3049 return m_buffer < rhs.m_buffer;
3050 }
3051 #endif
3052
operator VkBuffer() const3053 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBuffer() const VULKAN_HPP_NOEXCEPT
3054 {
3055 return m_buffer;
3056 }
3057
operator bool() const3058 explicit operator bool() const VULKAN_HPP_NOEXCEPT
3059 {
3060 return m_buffer != VK_NULL_HANDLE;
3061 }
3062
operator !() const3063 bool operator!() const VULKAN_HPP_NOEXCEPT
3064 {
3065 return m_buffer == VK_NULL_HANDLE;
3066 }
3067
3068 private:
3069 VkBuffer m_buffer = {};
3070 };
3071
3072 template <>
3073 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eBuffer>
3074 {
3075 using Type = VULKAN_HPP_NAMESPACE::Buffer;
3076 };
3077
3078
3079 template <>
3080 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBuffer>
3081 {
3082 using Type = VULKAN_HPP_NAMESPACE::Buffer;
3083 };
3084
3085
3086 template <>
3087 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Buffer>
3088 {
3089 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3090 };
3091
3092 class PipelineLayout
3093 {
3094 public:
3095 using CType = VkPipelineLayout;
3096 using NativeType = VkPipelineLayout;
3097
3098 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePipelineLayout;
3099 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineLayout;
3100
3101 public:
3102 VULKAN_HPP_CONSTEXPR PipelineLayout() = default;
PipelineLayout(std::nullptr_t)3103 VULKAN_HPP_CONSTEXPR PipelineLayout( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3104 {}
PipelineLayout(VkPipelineLayout pipelineLayout)3105 VULKAN_HPP_TYPESAFE_EXPLICIT PipelineLayout( VkPipelineLayout pipelineLayout ) VULKAN_HPP_NOEXCEPT
3106 : m_pipelineLayout( pipelineLayout )
3107 {}
3108
3109 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkPipelineLayout pipelineLayout)3110 PipelineLayout & operator=(VkPipelineLayout pipelineLayout) VULKAN_HPP_NOEXCEPT
3111 {
3112 m_pipelineLayout = pipelineLayout;
3113 return *this;
3114 }
3115 #endif
3116
operator =(std::nullptr_t)3117 PipelineLayout & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3118 {
3119 m_pipelineLayout = {};
3120 return *this;
3121 }
3122
3123 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
3124 auto operator<=>( PipelineLayout const & ) const = default;
3125 #else
operator ==(PipelineLayout const & rhs) const3126 bool operator==( PipelineLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
3127 {
3128 return m_pipelineLayout == rhs.m_pipelineLayout;
3129 }
3130
operator !=(PipelineLayout const & rhs) const3131 bool operator!=(PipelineLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
3132 {
3133 return m_pipelineLayout != rhs.m_pipelineLayout;
3134 }
3135
operator <(PipelineLayout const & rhs) const3136 bool operator<(PipelineLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
3137 {
3138 return m_pipelineLayout < rhs.m_pipelineLayout;
3139 }
3140 #endif
3141
operator VkPipelineLayout() const3142 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineLayout() const VULKAN_HPP_NOEXCEPT
3143 {
3144 return m_pipelineLayout;
3145 }
3146
operator bool() const3147 explicit operator bool() const VULKAN_HPP_NOEXCEPT
3148 {
3149 return m_pipelineLayout != VK_NULL_HANDLE;
3150 }
3151
operator !() const3152 bool operator!() const VULKAN_HPP_NOEXCEPT
3153 {
3154 return m_pipelineLayout == VK_NULL_HANDLE;
3155 }
3156
3157 private:
3158 VkPipelineLayout m_pipelineLayout = {};
3159 };
3160
3161 template <>
3162 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePipelineLayout>
3163 {
3164 using Type = VULKAN_HPP_NAMESPACE::PipelineLayout;
3165 };
3166
3167
3168 template <>
3169 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineLayout>
3170 {
3171 using Type = VULKAN_HPP_NAMESPACE::PipelineLayout;
3172 };
3173
3174
3175 template <>
3176 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PipelineLayout>
3177 {
3178 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3179 };
3180
3181 class DescriptorSet
3182 {
3183 public:
3184 using CType = VkDescriptorSet;
3185 using NativeType = VkDescriptorSet;
3186
3187 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSet;
3188 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSet;
3189
3190 public:
3191 VULKAN_HPP_CONSTEXPR DescriptorSet() = default;
DescriptorSet(std::nullptr_t)3192 VULKAN_HPP_CONSTEXPR DescriptorSet( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3193 {}
DescriptorSet(VkDescriptorSet descriptorSet)3194 VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSet( VkDescriptorSet descriptorSet ) VULKAN_HPP_NOEXCEPT
3195 : m_descriptorSet( descriptorSet )
3196 {}
3197
3198 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkDescriptorSet descriptorSet)3199 DescriptorSet & operator=(VkDescriptorSet descriptorSet) VULKAN_HPP_NOEXCEPT
3200 {
3201 m_descriptorSet = descriptorSet;
3202 return *this;
3203 }
3204 #endif
3205
operator =(std::nullptr_t)3206 DescriptorSet & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3207 {
3208 m_descriptorSet = {};
3209 return *this;
3210 }
3211
3212 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
3213 auto operator<=>( DescriptorSet const & ) const = default;
3214 #else
operator ==(DescriptorSet const & rhs) const3215 bool operator==( DescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT
3216 {
3217 return m_descriptorSet == rhs.m_descriptorSet;
3218 }
3219
operator !=(DescriptorSet const & rhs) const3220 bool operator!=(DescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT
3221 {
3222 return m_descriptorSet != rhs.m_descriptorSet;
3223 }
3224
operator <(DescriptorSet const & rhs) const3225 bool operator<(DescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT
3226 {
3227 return m_descriptorSet < rhs.m_descriptorSet;
3228 }
3229 #endif
3230
operator VkDescriptorSet() const3231 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorSet() const VULKAN_HPP_NOEXCEPT
3232 {
3233 return m_descriptorSet;
3234 }
3235
operator bool() const3236 explicit operator bool() const VULKAN_HPP_NOEXCEPT
3237 {
3238 return m_descriptorSet != VK_NULL_HANDLE;
3239 }
3240
operator !() const3241 bool operator!() const VULKAN_HPP_NOEXCEPT
3242 {
3243 return m_descriptorSet == VK_NULL_HANDLE;
3244 }
3245
3246 private:
3247 VkDescriptorSet m_descriptorSet = {};
3248 };
3249
3250 template <>
3251 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSet>
3252 {
3253 using Type = VULKAN_HPP_NAMESPACE::DescriptorSet;
3254 };
3255
3256
3257 template <>
3258 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSet>
3259 {
3260 using Type = VULKAN_HPP_NAMESPACE::DescriptorSet;
3261 };
3262
3263
3264 template <>
3265 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DescriptorSet>
3266 {
3267 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3268 };
3269
3270 class ImageView
3271 {
3272 public:
3273 using CType = VkImageView;
3274 using NativeType = VkImageView;
3275
3276 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eImageView;
3277 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImageView;
3278
3279 public:
3280 VULKAN_HPP_CONSTEXPR ImageView() = default;
ImageView(std::nullptr_t)3281 VULKAN_HPP_CONSTEXPR ImageView( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3282 {}
ImageView(VkImageView imageView)3283 VULKAN_HPP_TYPESAFE_EXPLICIT ImageView( VkImageView imageView ) VULKAN_HPP_NOEXCEPT
3284 : m_imageView( imageView )
3285 {}
3286
3287 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkImageView imageView)3288 ImageView & operator=(VkImageView imageView) VULKAN_HPP_NOEXCEPT
3289 {
3290 m_imageView = imageView;
3291 return *this;
3292 }
3293 #endif
3294
operator =(std::nullptr_t)3295 ImageView & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3296 {
3297 m_imageView = {};
3298 return *this;
3299 }
3300
3301 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
3302 auto operator<=>( ImageView const & ) const = default;
3303 #else
operator ==(ImageView const & rhs) const3304 bool operator==( ImageView const & rhs ) const VULKAN_HPP_NOEXCEPT
3305 {
3306 return m_imageView == rhs.m_imageView;
3307 }
3308
operator !=(ImageView const & rhs) const3309 bool operator!=(ImageView const & rhs ) const VULKAN_HPP_NOEXCEPT
3310 {
3311 return m_imageView != rhs.m_imageView;
3312 }
3313
operator <(ImageView const & rhs) const3314 bool operator<(ImageView const & rhs ) const VULKAN_HPP_NOEXCEPT
3315 {
3316 return m_imageView < rhs.m_imageView;
3317 }
3318 #endif
3319
operator VkImageView() const3320 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkImageView() const VULKAN_HPP_NOEXCEPT
3321 {
3322 return m_imageView;
3323 }
3324
operator bool() const3325 explicit operator bool() const VULKAN_HPP_NOEXCEPT
3326 {
3327 return m_imageView != VK_NULL_HANDLE;
3328 }
3329
operator !() const3330 bool operator!() const VULKAN_HPP_NOEXCEPT
3331 {
3332 return m_imageView == VK_NULL_HANDLE;
3333 }
3334
3335 private:
3336 VkImageView m_imageView = {};
3337 };
3338
3339 template <>
3340 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eImageView>
3341 {
3342 using Type = VULKAN_HPP_NAMESPACE::ImageView;
3343 };
3344
3345
3346 template <>
3347 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImageView>
3348 {
3349 using Type = VULKAN_HPP_NAMESPACE::ImageView;
3350 };
3351
3352
3353 template <>
3354 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::ImageView>
3355 {
3356 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3357 };
3358
3359 class Pipeline
3360 {
3361 public:
3362 using CType = VkPipeline;
3363 using NativeType = VkPipeline;
3364
3365 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePipeline;
3366 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipeline;
3367
3368 public:
3369 VULKAN_HPP_CONSTEXPR Pipeline() = default;
Pipeline(std::nullptr_t)3370 VULKAN_HPP_CONSTEXPR Pipeline( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3371 {}
Pipeline(VkPipeline pipeline)3372 VULKAN_HPP_TYPESAFE_EXPLICIT Pipeline( VkPipeline pipeline ) VULKAN_HPP_NOEXCEPT
3373 : m_pipeline( pipeline )
3374 {}
3375
3376 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkPipeline pipeline)3377 Pipeline & operator=(VkPipeline pipeline) VULKAN_HPP_NOEXCEPT
3378 {
3379 m_pipeline = pipeline;
3380 return *this;
3381 }
3382 #endif
3383
operator =(std::nullptr_t)3384 Pipeline & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3385 {
3386 m_pipeline = {};
3387 return *this;
3388 }
3389
3390 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
3391 auto operator<=>( Pipeline const & ) const = default;
3392 #else
operator ==(Pipeline const & rhs) const3393 bool operator==( Pipeline const & rhs ) const VULKAN_HPP_NOEXCEPT
3394 {
3395 return m_pipeline == rhs.m_pipeline;
3396 }
3397
operator !=(Pipeline const & rhs) const3398 bool operator!=(Pipeline const & rhs ) const VULKAN_HPP_NOEXCEPT
3399 {
3400 return m_pipeline != rhs.m_pipeline;
3401 }
3402
operator <(Pipeline const & rhs) const3403 bool operator<(Pipeline const & rhs ) const VULKAN_HPP_NOEXCEPT
3404 {
3405 return m_pipeline < rhs.m_pipeline;
3406 }
3407 #endif
3408
operator VkPipeline() const3409 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipeline() const VULKAN_HPP_NOEXCEPT
3410 {
3411 return m_pipeline;
3412 }
3413
operator bool() const3414 explicit operator bool() const VULKAN_HPP_NOEXCEPT
3415 {
3416 return m_pipeline != VK_NULL_HANDLE;
3417 }
3418
operator !() const3419 bool operator!() const VULKAN_HPP_NOEXCEPT
3420 {
3421 return m_pipeline == VK_NULL_HANDLE;
3422 }
3423
3424 private:
3425 VkPipeline m_pipeline = {};
3426 };
3427
3428 template <>
3429 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePipeline>
3430 {
3431 using Type = VULKAN_HPP_NAMESPACE::Pipeline;
3432 };
3433
3434
3435 template <>
3436 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipeline>
3437 {
3438 using Type = VULKAN_HPP_NAMESPACE::Pipeline;
3439 };
3440
3441
3442 template <>
3443 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Pipeline>
3444 {
3445 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3446 };
3447
3448 class ShaderEXT
3449 {
3450 public:
3451 using CType = VkShaderEXT;
3452 using NativeType = VkShaderEXT;
3453
3454 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eShaderEXT;
3455 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
3456
3457 public:
3458 VULKAN_HPP_CONSTEXPR ShaderEXT() = default;
ShaderEXT(std::nullptr_t)3459 VULKAN_HPP_CONSTEXPR ShaderEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3460 {}
ShaderEXT(VkShaderEXT shaderEXT)3461 VULKAN_HPP_TYPESAFE_EXPLICIT ShaderEXT( VkShaderEXT shaderEXT ) VULKAN_HPP_NOEXCEPT
3462 : m_shaderEXT( shaderEXT )
3463 {}
3464
3465 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkShaderEXT shaderEXT)3466 ShaderEXT & operator=(VkShaderEXT shaderEXT) VULKAN_HPP_NOEXCEPT
3467 {
3468 m_shaderEXT = shaderEXT;
3469 return *this;
3470 }
3471 #endif
3472
operator =(std::nullptr_t)3473 ShaderEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3474 {
3475 m_shaderEXT = {};
3476 return *this;
3477 }
3478
3479 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
3480 auto operator<=>( ShaderEXT const & ) const = default;
3481 #else
operator ==(ShaderEXT const & rhs) const3482 bool operator==( ShaderEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
3483 {
3484 return m_shaderEXT == rhs.m_shaderEXT;
3485 }
3486
operator !=(ShaderEXT const & rhs) const3487 bool operator!=(ShaderEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
3488 {
3489 return m_shaderEXT != rhs.m_shaderEXT;
3490 }
3491
operator <(ShaderEXT const & rhs) const3492 bool operator<(ShaderEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
3493 {
3494 return m_shaderEXT < rhs.m_shaderEXT;
3495 }
3496 #endif
3497
operator VkShaderEXT() const3498 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkShaderEXT() const VULKAN_HPP_NOEXCEPT
3499 {
3500 return m_shaderEXT;
3501 }
3502
operator bool() const3503 explicit operator bool() const VULKAN_HPP_NOEXCEPT
3504 {
3505 return m_shaderEXT != VK_NULL_HANDLE;
3506 }
3507
operator !() const3508 bool operator!() const VULKAN_HPP_NOEXCEPT
3509 {
3510 return m_shaderEXT == VK_NULL_HANDLE;
3511 }
3512
3513 private:
3514 VkShaderEXT m_shaderEXT = {};
3515 };
3516
3517 template <>
3518 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eShaderEXT>
3519 {
3520 using Type = VULKAN_HPP_NAMESPACE::ShaderEXT;
3521 };
3522
3523
3524
3525 template <>
3526 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::ShaderEXT>
3527 {
3528 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3529 };
3530
3531 class Image
3532 {
3533 public:
3534 using CType = VkImage;
3535 using NativeType = VkImage;
3536
3537 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eImage;
3538 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImage;
3539
3540 public:
3541 VULKAN_HPP_CONSTEXPR Image() = default;
Image(std::nullptr_t)3542 VULKAN_HPP_CONSTEXPR Image( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3543 {}
Image(VkImage image)3544 VULKAN_HPP_TYPESAFE_EXPLICIT Image( VkImage image ) VULKAN_HPP_NOEXCEPT
3545 : m_image( image )
3546 {}
3547
3548 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkImage image)3549 Image & operator=(VkImage image) VULKAN_HPP_NOEXCEPT
3550 {
3551 m_image = image;
3552 return *this;
3553 }
3554 #endif
3555
operator =(std::nullptr_t)3556 Image & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3557 {
3558 m_image = {};
3559 return *this;
3560 }
3561
3562 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
3563 auto operator<=>( Image const & ) const = default;
3564 #else
operator ==(Image const & rhs) const3565 bool operator==( Image const & rhs ) const VULKAN_HPP_NOEXCEPT
3566 {
3567 return m_image == rhs.m_image;
3568 }
3569
operator !=(Image const & rhs) const3570 bool operator!=(Image const & rhs ) const VULKAN_HPP_NOEXCEPT
3571 {
3572 return m_image != rhs.m_image;
3573 }
3574
operator <(Image const & rhs) const3575 bool operator<(Image const & rhs ) const VULKAN_HPP_NOEXCEPT
3576 {
3577 return m_image < rhs.m_image;
3578 }
3579 #endif
3580
operator VkImage() const3581 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkImage() const VULKAN_HPP_NOEXCEPT
3582 {
3583 return m_image;
3584 }
3585
operator bool() const3586 explicit operator bool() const VULKAN_HPP_NOEXCEPT
3587 {
3588 return m_image != VK_NULL_HANDLE;
3589 }
3590
operator !() const3591 bool operator!() const VULKAN_HPP_NOEXCEPT
3592 {
3593 return m_image == VK_NULL_HANDLE;
3594 }
3595
3596 private:
3597 VkImage m_image = {};
3598 };
3599
3600 template <>
3601 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eImage>
3602 {
3603 using Type = VULKAN_HPP_NAMESPACE::Image;
3604 };
3605
3606
3607 template <>
3608 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImage>
3609 {
3610 using Type = VULKAN_HPP_NAMESPACE::Image;
3611 };
3612
3613
3614 template <>
3615 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Image>
3616 {
3617 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3618 };
3619
3620 class AccelerationStructureNV
3621 {
3622 public:
3623 using CType = VkAccelerationStructureNV;
3624 using NativeType = VkAccelerationStructureNV;
3625
3626 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureNV;
3627 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureNV;
3628
3629 public:
3630 VULKAN_HPP_CONSTEXPR AccelerationStructureNV() = default;
AccelerationStructureNV(std::nullptr_t)3631 VULKAN_HPP_CONSTEXPR AccelerationStructureNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3632 {}
AccelerationStructureNV(VkAccelerationStructureNV accelerationStructureNV)3633 VULKAN_HPP_TYPESAFE_EXPLICIT AccelerationStructureNV( VkAccelerationStructureNV accelerationStructureNV ) VULKAN_HPP_NOEXCEPT
3634 : m_accelerationStructureNV( accelerationStructureNV )
3635 {}
3636
3637 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkAccelerationStructureNV accelerationStructureNV)3638 AccelerationStructureNV & operator=(VkAccelerationStructureNV accelerationStructureNV) VULKAN_HPP_NOEXCEPT
3639 {
3640 m_accelerationStructureNV = accelerationStructureNV;
3641 return *this;
3642 }
3643 #endif
3644
operator =(std::nullptr_t)3645 AccelerationStructureNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3646 {
3647 m_accelerationStructureNV = {};
3648 return *this;
3649 }
3650
3651 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
3652 auto operator<=>( AccelerationStructureNV const & ) const = default;
3653 #else
operator ==(AccelerationStructureNV const & rhs) const3654 bool operator==( AccelerationStructureNV const & rhs ) const VULKAN_HPP_NOEXCEPT
3655 {
3656 return m_accelerationStructureNV == rhs.m_accelerationStructureNV;
3657 }
3658
operator !=(AccelerationStructureNV const & rhs) const3659 bool operator!=(AccelerationStructureNV const & rhs ) const VULKAN_HPP_NOEXCEPT
3660 {
3661 return m_accelerationStructureNV != rhs.m_accelerationStructureNV;
3662 }
3663
operator <(AccelerationStructureNV const & rhs) const3664 bool operator<(AccelerationStructureNV const & rhs ) const VULKAN_HPP_NOEXCEPT
3665 {
3666 return m_accelerationStructureNV < rhs.m_accelerationStructureNV;
3667 }
3668 #endif
3669
operator VkAccelerationStructureNV() const3670 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkAccelerationStructureNV() const VULKAN_HPP_NOEXCEPT
3671 {
3672 return m_accelerationStructureNV;
3673 }
3674
operator bool() const3675 explicit operator bool() const VULKAN_HPP_NOEXCEPT
3676 {
3677 return m_accelerationStructureNV != VK_NULL_HANDLE;
3678 }
3679
operator !() const3680 bool operator!() const VULKAN_HPP_NOEXCEPT
3681 {
3682 return m_accelerationStructureNV == VK_NULL_HANDLE;
3683 }
3684
3685 private:
3686 VkAccelerationStructureNV m_accelerationStructureNV = {};
3687 };
3688
3689 template <>
3690 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureNV>
3691 {
3692 using Type = VULKAN_HPP_NAMESPACE::AccelerationStructureNV;
3693 };
3694
3695
3696 template <>
3697 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureNV>
3698 {
3699 using Type = VULKAN_HPP_NAMESPACE::AccelerationStructureNV;
3700 };
3701
3702
3703 template <>
3704 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::AccelerationStructureNV>
3705 {
3706 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3707 };
3708
3709 class OpticalFlowSessionNV
3710 {
3711 public:
3712 using CType = VkOpticalFlowSessionNV;
3713 using NativeType = VkOpticalFlowSessionNV;
3714
3715 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eOpticalFlowSessionNV;
3716 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
3717
3718 public:
3719 VULKAN_HPP_CONSTEXPR OpticalFlowSessionNV() = default;
OpticalFlowSessionNV(std::nullptr_t)3720 VULKAN_HPP_CONSTEXPR OpticalFlowSessionNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3721 {}
OpticalFlowSessionNV(VkOpticalFlowSessionNV opticalFlowSessionNV)3722 VULKAN_HPP_TYPESAFE_EXPLICIT OpticalFlowSessionNV( VkOpticalFlowSessionNV opticalFlowSessionNV ) VULKAN_HPP_NOEXCEPT
3723 : m_opticalFlowSessionNV( opticalFlowSessionNV )
3724 {}
3725
3726 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkOpticalFlowSessionNV opticalFlowSessionNV)3727 OpticalFlowSessionNV & operator=(VkOpticalFlowSessionNV opticalFlowSessionNV) VULKAN_HPP_NOEXCEPT
3728 {
3729 m_opticalFlowSessionNV = opticalFlowSessionNV;
3730 return *this;
3731 }
3732 #endif
3733
operator =(std::nullptr_t)3734 OpticalFlowSessionNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3735 {
3736 m_opticalFlowSessionNV = {};
3737 return *this;
3738 }
3739
3740 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
3741 auto operator<=>( OpticalFlowSessionNV const & ) const = default;
3742 #else
operator ==(OpticalFlowSessionNV const & rhs) const3743 bool operator==( OpticalFlowSessionNV const & rhs ) const VULKAN_HPP_NOEXCEPT
3744 {
3745 return m_opticalFlowSessionNV == rhs.m_opticalFlowSessionNV;
3746 }
3747
operator !=(OpticalFlowSessionNV const & rhs) const3748 bool operator!=(OpticalFlowSessionNV const & rhs ) const VULKAN_HPP_NOEXCEPT
3749 {
3750 return m_opticalFlowSessionNV != rhs.m_opticalFlowSessionNV;
3751 }
3752
operator <(OpticalFlowSessionNV const & rhs) const3753 bool operator<(OpticalFlowSessionNV const & rhs ) const VULKAN_HPP_NOEXCEPT
3754 {
3755 return m_opticalFlowSessionNV < rhs.m_opticalFlowSessionNV;
3756 }
3757 #endif
3758
operator VkOpticalFlowSessionNV() const3759 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkOpticalFlowSessionNV() const VULKAN_HPP_NOEXCEPT
3760 {
3761 return m_opticalFlowSessionNV;
3762 }
3763
operator bool() const3764 explicit operator bool() const VULKAN_HPP_NOEXCEPT
3765 {
3766 return m_opticalFlowSessionNV != VK_NULL_HANDLE;
3767 }
3768
operator !() const3769 bool operator!() const VULKAN_HPP_NOEXCEPT
3770 {
3771 return m_opticalFlowSessionNV == VK_NULL_HANDLE;
3772 }
3773
3774 private:
3775 VkOpticalFlowSessionNV m_opticalFlowSessionNV = {};
3776 };
3777
3778 template <>
3779 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eOpticalFlowSessionNV>
3780 {
3781 using Type = VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV;
3782 };
3783
3784
3785
3786 template <>
3787 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV>
3788 {
3789 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3790 };
3791
3792 class DescriptorUpdateTemplate
3793 {
3794 public:
3795 using CType = VkDescriptorUpdateTemplate;
3796 using NativeType = VkDescriptorUpdateTemplate;
3797
3798 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorUpdateTemplate;
3799 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorUpdateTemplate;
3800
3801 public:
3802 VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplate() = default;
DescriptorUpdateTemplate(std::nullptr_t)3803 VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplate( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3804 {}
DescriptorUpdateTemplate(VkDescriptorUpdateTemplate descriptorUpdateTemplate)3805 VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorUpdateTemplate( VkDescriptorUpdateTemplate descriptorUpdateTemplate ) VULKAN_HPP_NOEXCEPT
3806 : m_descriptorUpdateTemplate( descriptorUpdateTemplate )
3807 {}
3808
3809 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkDescriptorUpdateTemplate descriptorUpdateTemplate)3810 DescriptorUpdateTemplate & operator=(VkDescriptorUpdateTemplate descriptorUpdateTemplate) VULKAN_HPP_NOEXCEPT
3811 {
3812 m_descriptorUpdateTemplate = descriptorUpdateTemplate;
3813 return *this;
3814 }
3815 #endif
3816
operator =(std::nullptr_t)3817 DescriptorUpdateTemplate & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3818 {
3819 m_descriptorUpdateTemplate = {};
3820 return *this;
3821 }
3822
3823 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
3824 auto operator<=>( DescriptorUpdateTemplate const & ) const = default;
3825 #else
operator ==(DescriptorUpdateTemplate const & rhs) const3826 bool operator==( DescriptorUpdateTemplate const & rhs ) const VULKAN_HPP_NOEXCEPT
3827 {
3828 return m_descriptorUpdateTemplate == rhs.m_descriptorUpdateTemplate;
3829 }
3830
operator !=(DescriptorUpdateTemplate const & rhs) const3831 bool operator!=(DescriptorUpdateTemplate const & rhs ) const VULKAN_HPP_NOEXCEPT
3832 {
3833 return m_descriptorUpdateTemplate != rhs.m_descriptorUpdateTemplate;
3834 }
3835
operator <(DescriptorUpdateTemplate const & rhs) const3836 bool operator<(DescriptorUpdateTemplate const & rhs ) const VULKAN_HPP_NOEXCEPT
3837 {
3838 return m_descriptorUpdateTemplate < rhs.m_descriptorUpdateTemplate;
3839 }
3840 #endif
3841
operator VkDescriptorUpdateTemplate() const3842 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorUpdateTemplate() const VULKAN_HPP_NOEXCEPT
3843 {
3844 return m_descriptorUpdateTemplate;
3845 }
3846
operator bool() const3847 explicit operator bool() const VULKAN_HPP_NOEXCEPT
3848 {
3849 return m_descriptorUpdateTemplate != VK_NULL_HANDLE;
3850 }
3851
operator !() const3852 bool operator!() const VULKAN_HPP_NOEXCEPT
3853 {
3854 return m_descriptorUpdateTemplate == VK_NULL_HANDLE;
3855 }
3856
3857 private:
3858 VkDescriptorUpdateTemplate m_descriptorUpdateTemplate = {};
3859 };
3860
3861 template <>
3862 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorUpdateTemplate>
3863 {
3864 using Type = VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate;
3865 };
3866
3867
3868 template <>
3869 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorUpdateTemplate>
3870 {
3871 using Type = VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate;
3872 };
3873
3874
3875 template <>
3876 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate>
3877 {
3878 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3879 };
3880 using DescriptorUpdateTemplateKHR = DescriptorUpdateTemplate;
3881
3882 class Event
3883 {
3884 public:
3885 using CType = VkEvent;
3886 using NativeType = VkEvent;
3887
3888 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eEvent;
3889 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eEvent;
3890
3891 public:
3892 VULKAN_HPP_CONSTEXPR Event() = default;
Event(std::nullptr_t)3893 VULKAN_HPP_CONSTEXPR Event( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3894 {}
Event(VkEvent event)3895 VULKAN_HPP_TYPESAFE_EXPLICIT Event( VkEvent event ) VULKAN_HPP_NOEXCEPT
3896 : m_event( event )
3897 {}
3898
3899 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkEvent event)3900 Event & operator=(VkEvent event) VULKAN_HPP_NOEXCEPT
3901 {
3902 m_event = event;
3903 return *this;
3904 }
3905 #endif
3906
operator =(std::nullptr_t)3907 Event & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3908 {
3909 m_event = {};
3910 return *this;
3911 }
3912
3913 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
3914 auto operator<=>( Event const & ) const = default;
3915 #else
operator ==(Event const & rhs) const3916 bool operator==( Event const & rhs ) const VULKAN_HPP_NOEXCEPT
3917 {
3918 return m_event == rhs.m_event;
3919 }
3920
operator !=(Event const & rhs) const3921 bool operator!=(Event const & rhs ) const VULKAN_HPP_NOEXCEPT
3922 {
3923 return m_event != rhs.m_event;
3924 }
3925
operator <(Event const & rhs) const3926 bool operator<(Event const & rhs ) const VULKAN_HPP_NOEXCEPT
3927 {
3928 return m_event < rhs.m_event;
3929 }
3930 #endif
3931
operator VkEvent() const3932 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkEvent() const VULKAN_HPP_NOEXCEPT
3933 {
3934 return m_event;
3935 }
3936
operator bool() const3937 explicit operator bool() const VULKAN_HPP_NOEXCEPT
3938 {
3939 return m_event != VK_NULL_HANDLE;
3940 }
3941
operator !() const3942 bool operator!() const VULKAN_HPP_NOEXCEPT
3943 {
3944 return m_event == VK_NULL_HANDLE;
3945 }
3946
3947 private:
3948 VkEvent m_event = {};
3949 };
3950
3951 template <>
3952 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eEvent>
3953 {
3954 using Type = VULKAN_HPP_NAMESPACE::Event;
3955 };
3956
3957
3958 template <>
3959 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eEvent>
3960 {
3961 using Type = VULKAN_HPP_NAMESPACE::Event;
3962 };
3963
3964
3965 template <>
3966 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Event>
3967 {
3968 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3969 };
3970
3971 class AccelerationStructureKHR
3972 {
3973 public:
3974 using CType = VkAccelerationStructureKHR;
3975 using NativeType = VkAccelerationStructureKHR;
3976
3977 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureKHR;
3978 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureKHR;
3979
3980 public:
3981 VULKAN_HPP_CONSTEXPR AccelerationStructureKHR() = default;
AccelerationStructureKHR(std::nullptr_t)3982 VULKAN_HPP_CONSTEXPR AccelerationStructureKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3983 {}
AccelerationStructureKHR(VkAccelerationStructureKHR accelerationStructureKHR)3984 VULKAN_HPP_TYPESAFE_EXPLICIT AccelerationStructureKHR( VkAccelerationStructureKHR accelerationStructureKHR ) VULKAN_HPP_NOEXCEPT
3985 : m_accelerationStructureKHR( accelerationStructureKHR )
3986 {}
3987
3988 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkAccelerationStructureKHR accelerationStructureKHR)3989 AccelerationStructureKHR & operator=(VkAccelerationStructureKHR accelerationStructureKHR) VULKAN_HPP_NOEXCEPT
3990 {
3991 m_accelerationStructureKHR = accelerationStructureKHR;
3992 return *this;
3993 }
3994 #endif
3995
operator =(std::nullptr_t)3996 AccelerationStructureKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3997 {
3998 m_accelerationStructureKHR = {};
3999 return *this;
4000 }
4001
4002 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
4003 auto operator<=>( AccelerationStructureKHR const & ) const = default;
4004 #else
operator ==(AccelerationStructureKHR const & rhs) const4005 bool operator==( AccelerationStructureKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
4006 {
4007 return m_accelerationStructureKHR == rhs.m_accelerationStructureKHR;
4008 }
4009
operator !=(AccelerationStructureKHR const & rhs) const4010 bool operator!=(AccelerationStructureKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
4011 {
4012 return m_accelerationStructureKHR != rhs.m_accelerationStructureKHR;
4013 }
4014
operator <(AccelerationStructureKHR const & rhs) const4015 bool operator<(AccelerationStructureKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
4016 {
4017 return m_accelerationStructureKHR < rhs.m_accelerationStructureKHR;
4018 }
4019 #endif
4020
operator VkAccelerationStructureKHR() const4021 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkAccelerationStructureKHR() const VULKAN_HPP_NOEXCEPT
4022 {
4023 return m_accelerationStructureKHR;
4024 }
4025
operator bool() const4026 explicit operator bool() const VULKAN_HPP_NOEXCEPT
4027 {
4028 return m_accelerationStructureKHR != VK_NULL_HANDLE;
4029 }
4030
operator !() const4031 bool operator!() const VULKAN_HPP_NOEXCEPT
4032 {
4033 return m_accelerationStructureKHR == VK_NULL_HANDLE;
4034 }
4035
4036 private:
4037 VkAccelerationStructureKHR m_accelerationStructureKHR = {};
4038 };
4039
4040 template <>
4041 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureKHR>
4042 {
4043 using Type = VULKAN_HPP_NAMESPACE::AccelerationStructureKHR;
4044 };
4045
4046
4047 template <>
4048 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureKHR>
4049 {
4050 using Type = VULKAN_HPP_NAMESPACE::AccelerationStructureKHR;
4051 };
4052
4053
4054 template <>
4055 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR>
4056 {
4057 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
4058 };
4059
4060 class MicromapEXT
4061 {
4062 public:
4063 using CType = VkMicromapEXT;
4064 using NativeType = VkMicromapEXT;
4065
4066 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eMicromapEXT;
4067 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
4068
4069 public:
4070 VULKAN_HPP_CONSTEXPR MicromapEXT() = default;
MicromapEXT(std::nullptr_t)4071 VULKAN_HPP_CONSTEXPR MicromapEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
4072 {}
MicromapEXT(VkMicromapEXT micromapEXT)4073 VULKAN_HPP_TYPESAFE_EXPLICIT MicromapEXT( VkMicromapEXT micromapEXT ) VULKAN_HPP_NOEXCEPT
4074 : m_micromapEXT( micromapEXT )
4075 {}
4076
4077 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkMicromapEXT micromapEXT)4078 MicromapEXT & operator=(VkMicromapEXT micromapEXT) VULKAN_HPP_NOEXCEPT
4079 {
4080 m_micromapEXT = micromapEXT;
4081 return *this;
4082 }
4083 #endif
4084
operator =(std::nullptr_t)4085 MicromapEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
4086 {
4087 m_micromapEXT = {};
4088 return *this;
4089 }
4090
4091 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
4092 auto operator<=>( MicromapEXT const & ) const = default;
4093 #else
operator ==(MicromapEXT const & rhs) const4094 bool operator==( MicromapEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
4095 {
4096 return m_micromapEXT == rhs.m_micromapEXT;
4097 }
4098
operator !=(MicromapEXT const & rhs) const4099 bool operator!=(MicromapEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
4100 {
4101 return m_micromapEXT != rhs.m_micromapEXT;
4102 }
4103
operator <(MicromapEXT const & rhs) const4104 bool operator<(MicromapEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
4105 {
4106 return m_micromapEXT < rhs.m_micromapEXT;
4107 }
4108 #endif
4109
operator VkMicromapEXT() const4110 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkMicromapEXT() const VULKAN_HPP_NOEXCEPT
4111 {
4112 return m_micromapEXT;
4113 }
4114
operator bool() const4115 explicit operator bool() const VULKAN_HPP_NOEXCEPT
4116 {
4117 return m_micromapEXT != VK_NULL_HANDLE;
4118 }
4119
operator !() const4120 bool operator!() const VULKAN_HPP_NOEXCEPT
4121 {
4122 return m_micromapEXT == VK_NULL_HANDLE;
4123 }
4124
4125 private:
4126 VkMicromapEXT m_micromapEXT = {};
4127 };
4128
4129 template <>
4130 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eMicromapEXT>
4131 {
4132 using Type = VULKAN_HPP_NAMESPACE::MicromapEXT;
4133 };
4134
4135
4136
4137 template <>
4138 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::MicromapEXT>
4139 {
4140 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
4141 };
4142
4143 class CommandBuffer
4144 {
4145 public:
4146 using CType = VkCommandBuffer;
4147 using NativeType = VkCommandBuffer;
4148
4149 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCommandBuffer;
4150 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandBuffer;
4151
4152 public:
4153 VULKAN_HPP_CONSTEXPR CommandBuffer() = default;
CommandBuffer(std::nullptr_t)4154 VULKAN_HPP_CONSTEXPR CommandBuffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
4155 {}
CommandBuffer(VkCommandBuffer commandBuffer)4156 CommandBuffer( VkCommandBuffer commandBuffer ) VULKAN_HPP_NOEXCEPT
4157 : m_commandBuffer( commandBuffer )
4158 {}
4159
operator =(VkCommandBuffer commandBuffer)4160 CommandBuffer & operator=(VkCommandBuffer commandBuffer) VULKAN_HPP_NOEXCEPT
4161 {
4162 m_commandBuffer = commandBuffer;
4163 return *this;
4164 }
4165
operator =(std::nullptr_t)4166 CommandBuffer & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
4167 {
4168 m_commandBuffer = {};
4169 return *this;
4170 }
4171
4172 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
4173 auto operator<=>( CommandBuffer const & ) const = default;
4174 #else
operator ==(CommandBuffer const & rhs) const4175 bool operator==( CommandBuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
4176 {
4177 return m_commandBuffer == rhs.m_commandBuffer;
4178 }
4179
operator !=(CommandBuffer const & rhs) const4180 bool operator!=(CommandBuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
4181 {
4182 return m_commandBuffer != rhs.m_commandBuffer;
4183 }
4184
operator <(CommandBuffer const & rhs) const4185 bool operator<(CommandBuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
4186 {
4187 return m_commandBuffer < rhs.m_commandBuffer;
4188 }
4189 #endif
4190
4191 //=== VK_VERSION_1_0 ===
4192
4193
4194 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4195 VULKAN_HPP_NODISCARD Result begin( const VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo * pBeginInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4196 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4197 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4198 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type begin( const VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo & beginInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
4199 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4200
4201
4202 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
4203 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4204 VULKAN_HPP_NODISCARD Result end( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4205 #else
4206 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4207 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type end( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
4208 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4209
4210
4211 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
4212 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4213 VULKAN_HPP_NODISCARD Result reset( VULKAN_HPP_NAMESPACE::CommandBufferResetFlags flags, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4214 #else
4215 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4216 typename ResultValueType<void>::type reset( VULKAN_HPP_NAMESPACE::CommandBufferResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
4217 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4218
4219
4220 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4221 void bindPipeline( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, VULKAN_HPP_NAMESPACE::Pipeline pipeline, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4222
4223
4224 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4225 void setViewport( uint32_t firstViewport, uint32_t viewportCount, const VULKAN_HPP_NAMESPACE::Viewport * pViewports, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4226 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4227 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4228 void setViewport( uint32_t firstViewport, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4229 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4230
4231
4232 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4233 void setScissor( uint32_t firstScissor, uint32_t scissorCount, const VULKAN_HPP_NAMESPACE::Rect2D * pScissors, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4234 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4235 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4236 void setScissor( uint32_t firstScissor, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4237 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4238
4239
4240 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4241 void setLineWidth( float lineWidth, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4242
4243
4244 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4245 void setDepthBias( float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4246
4247
4248 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4249 void setBlendConstants( const float blendConstants[4], Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4250
4251
4252 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4253 void setDepthBounds( float minDepthBounds, float maxDepthBounds, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4254
4255
4256 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4257 void setStencilCompareMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, uint32_t compareMask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4258
4259
4260 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4261 void setStencilWriteMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, uint32_t writeMask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4262
4263
4264 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4265 void setStencilReference( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, uint32_t reference, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4266
4267
4268 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4269 void bindDescriptorSets( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, VULKAN_HPP_NAMESPACE::PipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VULKAN_HPP_NAMESPACE::DescriptorSet * pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t * pDynamicOffsets, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4270 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4271 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4272 void bindDescriptorSets( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, VULKAN_HPP_NAMESPACE::PipelineLayout layout, uint32_t firstSet, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const & descriptorSets, VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t> const & dynamicOffsets, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4273 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4274
4275
4276 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4277 void bindIndexBuffer( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::IndexType indexType, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4278
4279
4280 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4281 void bindVertexBuffers( uint32_t firstBinding, uint32_t bindingCount, const VULKAN_HPP_NAMESPACE::Buffer * pBuffers, const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4282 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4283 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4284 void bindVertexBuffers( uint32_t firstBinding, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
4285 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4286
4287
4288 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4289 void draw( uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4290
4291
4292 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4293 void drawIndexed( uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4294
4295
4296 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4297 void drawIndirect( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4298
4299
4300 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4301 void drawIndexedIndirect( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4302
4303
4304 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4305 void dispatch( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4306
4307
4308 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4309 void dispatchIndirect( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4310
4311
4312 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4313 void copyBuffer( VULKAN_HPP_NAMESPACE::Buffer srcBuffer, VULKAN_HPP_NAMESPACE::Buffer dstBuffer, uint32_t regionCount, const VULKAN_HPP_NAMESPACE::BufferCopy * pRegions, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4314 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4315 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4316 void copyBuffer( VULKAN_HPP_NAMESPACE::Buffer srcBuffer, VULKAN_HPP_NAMESPACE::Buffer dstBuffer, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferCopy> const & regions, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4317 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4318
4319
4320 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4321 void copyImage( VULKAN_HPP_NAMESPACE::Image srcImage, VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, VULKAN_HPP_NAMESPACE::Image dstImage, VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, uint32_t regionCount, const VULKAN_HPP_NAMESPACE::ImageCopy * pRegions, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4322 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4323 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4324 void copyImage( VULKAN_HPP_NAMESPACE::Image srcImage, VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, VULKAN_HPP_NAMESPACE::Image dstImage, VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageCopy> const & regions, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4325 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4326
4327
4328 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4329 void blitImage( VULKAN_HPP_NAMESPACE::Image srcImage, VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, VULKAN_HPP_NAMESPACE::Image dstImage, VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, uint32_t regionCount, const VULKAN_HPP_NAMESPACE::ImageBlit * pRegions, VULKAN_HPP_NAMESPACE::Filter filter, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4330 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4331 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4332 void blitImage( VULKAN_HPP_NAMESPACE::Image srcImage, VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, VULKAN_HPP_NAMESPACE::Image dstImage, VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageBlit> const & regions, VULKAN_HPP_NAMESPACE::Filter filter, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4333 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4334
4335
4336 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4337 void copyBufferToImage( VULKAN_HPP_NAMESPACE::Buffer srcBuffer, VULKAN_HPP_NAMESPACE::Image dstImage, VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, uint32_t regionCount, const VULKAN_HPP_NAMESPACE::BufferImageCopy * pRegions, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4338 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4339 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4340 void copyBufferToImage( VULKAN_HPP_NAMESPACE::Buffer srcBuffer, VULKAN_HPP_NAMESPACE::Image dstImage, VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const & regions, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4341 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4342
4343
4344 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4345 void copyImageToBuffer( VULKAN_HPP_NAMESPACE::Image srcImage, VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, VULKAN_HPP_NAMESPACE::Buffer dstBuffer, uint32_t regionCount, const VULKAN_HPP_NAMESPACE::BufferImageCopy * pRegions, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4346 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4347 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4348 void copyImageToBuffer( VULKAN_HPP_NAMESPACE::Image srcImage, VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, VULKAN_HPP_NAMESPACE::Buffer dstBuffer, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const & regions, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4349 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4350
4351
4352 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4353 void updateBuffer( VULKAN_HPP_NAMESPACE::Buffer dstBuffer, VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, VULKAN_HPP_NAMESPACE::DeviceSize dataSize, const void * pData, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4354 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4355 template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4356 void updateBuffer( VULKAN_HPP_NAMESPACE::Buffer dstBuffer, VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, VULKAN_HPP_NAMESPACE::ArrayProxy<const DataType> const & data, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4357 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4358
4359
4360 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4361 void fillBuffer( VULKAN_HPP_NAMESPACE::Buffer dstBuffer, VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, VULKAN_HPP_NAMESPACE::DeviceSize size, uint32_t data, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4362
4363
4364 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4365 void clearColorImage( VULKAN_HPP_NAMESPACE::Image image, VULKAN_HPP_NAMESPACE::ImageLayout imageLayout, const VULKAN_HPP_NAMESPACE::ClearColorValue * pColor, uint32_t rangeCount, const VULKAN_HPP_NAMESPACE::ImageSubresourceRange * pRanges, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4366 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4367 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4368 void clearColorImage( VULKAN_HPP_NAMESPACE::Image image, VULKAN_HPP_NAMESPACE::ImageLayout imageLayout, const VULKAN_HPP_NAMESPACE::ClearColorValue & color, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceRange> const & ranges, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4369 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4370
4371
4372 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4373 void clearDepthStencilImage( VULKAN_HPP_NAMESPACE::Image image, VULKAN_HPP_NAMESPACE::ImageLayout imageLayout, const VULKAN_HPP_NAMESPACE::ClearDepthStencilValue * pDepthStencil, uint32_t rangeCount, const VULKAN_HPP_NAMESPACE::ImageSubresourceRange * pRanges, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4374 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4375 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4376 void clearDepthStencilImage( VULKAN_HPP_NAMESPACE::Image image, VULKAN_HPP_NAMESPACE::ImageLayout imageLayout, const VULKAN_HPP_NAMESPACE::ClearDepthStencilValue & depthStencil, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceRange> const & ranges, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4377 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4378
4379
4380 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4381 void clearAttachments( uint32_t attachmentCount, const VULKAN_HPP_NAMESPACE::ClearAttachment * pAttachments, uint32_t rectCount, const VULKAN_HPP_NAMESPACE::ClearRect * pRects, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4382 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4383 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4384 void clearAttachments( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearAttachment> const & attachments, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearRect> const & rects, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4385 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4386
4387
4388 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4389 void resolveImage( VULKAN_HPP_NAMESPACE::Image srcImage, VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, VULKAN_HPP_NAMESPACE::Image dstImage, VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, uint32_t regionCount, const VULKAN_HPP_NAMESPACE::ImageResolve * pRegions, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4390 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4391 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4392 void resolveImage( VULKAN_HPP_NAMESPACE::Image srcImage, VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, VULKAN_HPP_NAMESPACE::Image dstImage, VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageResolve> const & regions, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4393 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4394
4395
4396 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4397 void setEvent( VULKAN_HPP_NAMESPACE::Event event, VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4398
4399
4400 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4401 void resetEvent( VULKAN_HPP_NAMESPACE::Event event, VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4402
4403
4404 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4405 void waitEvents( uint32_t eventCount, const VULKAN_HPP_NAMESPACE::Event * pEvents, VULKAN_HPP_NAMESPACE::PipelineStageFlags srcStageMask, VULKAN_HPP_NAMESPACE::PipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VULKAN_HPP_NAMESPACE::MemoryBarrier * pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier * pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier * pImageMemoryBarriers, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4406 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4407 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4408 void waitEvents( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const & events, VULKAN_HPP_NAMESPACE::PipelineStageFlags srcStageMask, VULKAN_HPP_NAMESPACE::PipelineStageFlags dstStageMask, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryBarrier> const & memoryBarriers, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> const & bufferMemoryBarriers, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> const & imageMemoryBarriers, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4409 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4410
4411
4412 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4413 void pipelineBarrier( VULKAN_HPP_NAMESPACE::PipelineStageFlags srcStageMask, VULKAN_HPP_NAMESPACE::PipelineStageFlags dstStageMask, VULKAN_HPP_NAMESPACE::DependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VULKAN_HPP_NAMESPACE::MemoryBarrier * pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier * pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier * pImageMemoryBarriers, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4414 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4415 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4416 void pipelineBarrier( VULKAN_HPP_NAMESPACE::PipelineStageFlags srcStageMask, VULKAN_HPP_NAMESPACE::PipelineStageFlags dstStageMask, VULKAN_HPP_NAMESPACE::DependencyFlags dependencyFlags, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryBarrier> const & memoryBarriers, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> const & bufferMemoryBarriers, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> const & imageMemoryBarriers, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4417 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4418
4419
4420 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4421 void beginQuery( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query, VULKAN_HPP_NAMESPACE::QueryControlFlags flags, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4422
4423
4424 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4425 void endQuery( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4426
4427
4428 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4429 void resetQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4430
4431
4432 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4433 void writeTimestamp( VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage, VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4434
4435
4436 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4437 void copyQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VULKAN_HPP_NAMESPACE::Buffer dstBuffer, VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, VULKAN_HPP_NAMESPACE::DeviceSize stride, VULKAN_HPP_NAMESPACE::QueryResultFlags flags, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4438
4439
4440 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4441 void pushConstants( VULKAN_HPP_NAMESPACE::PipelineLayout layout, VULKAN_HPP_NAMESPACE::ShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void * pValues, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4442 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4443 template <typename ValuesType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4444 void pushConstants( VULKAN_HPP_NAMESPACE::PipelineLayout layout, VULKAN_HPP_NAMESPACE::ShaderStageFlags stageFlags, uint32_t offset, VULKAN_HPP_NAMESPACE::ArrayProxy<const ValuesType> const & values, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4445 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4446
4447
4448 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4449 void beginRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo * pRenderPassBegin, VULKAN_HPP_NAMESPACE::SubpassContents contents, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4450 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4451 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4452 void beginRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin, VULKAN_HPP_NAMESPACE::SubpassContents contents, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4453 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4454
4455
4456 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4457 void nextSubpass( VULKAN_HPP_NAMESPACE::SubpassContents contents, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4458
4459
4460 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4461 void endRenderPass( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4462
4463
4464 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4465 void executeCommands( uint32_t commandBufferCount, const VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4466 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4467 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4468 void executeCommands( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4469 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4470
4471 //=== VK_VERSION_1_1 ===
4472
4473
4474 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4475 void setDeviceMask( uint32_t deviceMask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4476
4477
4478 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4479 void dispatchBase( uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4480
4481 //=== VK_VERSION_1_2 ===
4482
4483
4484 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4485 void drawIndirectCount( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::Buffer countBuffer, VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4486
4487
4488 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4489 void drawIndexedIndirectCount( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::Buffer countBuffer, VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4490
4491
4492 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4493 void beginRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo * pRenderPassBegin, const VULKAN_HPP_NAMESPACE::SubpassBeginInfo * pSubpassBeginInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4494 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4495 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4496 void beginRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin, const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4497 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4498
4499
4500 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4501 void nextSubpass2( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo * pSubpassBeginInfo, const VULKAN_HPP_NAMESPACE::SubpassEndInfo * pSubpassEndInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4502 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4503 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4504 void nextSubpass2( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo, const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4505 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4506
4507
4508 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4509 void endRenderPass2( const VULKAN_HPP_NAMESPACE::SubpassEndInfo * pSubpassEndInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4510 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4511 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4512 void endRenderPass2( const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4513 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4514
4515 //=== VK_VERSION_1_3 ===
4516
4517
4518 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4519 void setEvent2( VULKAN_HPP_NAMESPACE::Event event, const VULKAN_HPP_NAMESPACE::DependencyInfo * pDependencyInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4520 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4521 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4522 void setEvent2( VULKAN_HPP_NAMESPACE::Event event, const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4523 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4524
4525
4526 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4527 void resetEvent2( VULKAN_HPP_NAMESPACE::Event event, VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stageMask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4528
4529
4530 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4531 void waitEvents2( uint32_t eventCount, const VULKAN_HPP_NAMESPACE::Event * pEvents, const VULKAN_HPP_NAMESPACE::DependencyInfo * pDependencyInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4532 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4533 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4534 void waitEvents2( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const & events, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DependencyInfo> const & dependencyInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
4535 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4536
4537
4538 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4539 void pipelineBarrier2( const VULKAN_HPP_NAMESPACE::DependencyInfo * pDependencyInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4540 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4541 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4542 void pipelineBarrier2( const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4543 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4544
4545
4546 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4547 void writeTimestamp2( VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stage, VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4548
4549
4550 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4551 void copyBuffer2( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 * pCopyBufferInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4552 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4553 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4554 void copyBuffer2( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 & copyBufferInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4555 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4556
4557
4558 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4559 void copyImage2( const VULKAN_HPP_NAMESPACE::CopyImageInfo2 * pCopyImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4560 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4561 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4562 void copyImage2( const VULKAN_HPP_NAMESPACE::CopyImageInfo2 & copyImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4563 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4564
4565
4566 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4567 void copyBufferToImage2( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 * pCopyBufferToImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4568 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4569 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4570 void copyBufferToImage2( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 & copyBufferToImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4571 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4572
4573
4574 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4575 void copyImageToBuffer2( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 * pCopyImageToBufferInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4576 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4577 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4578 void copyImageToBuffer2( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 & copyImageToBufferInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4579 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4580
4581
4582 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4583 void blitImage2( const VULKAN_HPP_NAMESPACE::BlitImageInfo2 * pBlitImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4584 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4585 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4586 void blitImage2( const VULKAN_HPP_NAMESPACE::BlitImageInfo2 & blitImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4587 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4588
4589
4590 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4591 void resolveImage2( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 * pResolveImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4592 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4593 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4594 void resolveImage2( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 & resolveImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4595 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4596
4597
4598 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4599 void beginRendering( const VULKAN_HPP_NAMESPACE::RenderingInfo * pRenderingInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4600 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4601 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4602 void beginRendering( const VULKAN_HPP_NAMESPACE::RenderingInfo & renderingInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4603 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4604
4605
4606 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4607 void endRendering( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4608
4609
4610 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4611 void setCullMode( VULKAN_HPP_NAMESPACE::CullModeFlags cullMode, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4612
4613
4614 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4615 void setFrontFace( VULKAN_HPP_NAMESPACE::FrontFace frontFace, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4616
4617
4618 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4619 void setPrimitiveTopology( VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4620
4621
4622 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4623 void setViewportWithCount( uint32_t viewportCount, const VULKAN_HPP_NAMESPACE::Viewport * pViewports, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4624 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4625 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4626 void setViewportWithCount( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4627 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4628
4629
4630 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4631 void setScissorWithCount( uint32_t scissorCount, const VULKAN_HPP_NAMESPACE::Rect2D * pScissors, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4632 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4633 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4634 void setScissorWithCount( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4635 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4636
4637
4638 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4639 void bindVertexBuffers2( uint32_t firstBinding, uint32_t bindingCount, const VULKAN_HPP_NAMESPACE::Buffer * pBuffers, const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets, const VULKAN_HPP_NAMESPACE::DeviceSize * pSizes, const VULKAN_HPP_NAMESPACE::DeviceSize * pStrides, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4640 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4641 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4642 void bindVertexBuffers2( uint32_t firstBinding, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & strides VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
4643 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4644
4645
4646 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4647 void setDepthTestEnable( VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4648
4649
4650 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4651 void setDepthWriteEnable( VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4652
4653
4654 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4655 void setDepthCompareOp( VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4656
4657
4658 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4659 void setDepthBoundsTestEnable( VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4660
4661
4662 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4663 void setStencilTestEnable( VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4664
4665
4666 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4667 void setStencilOp( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, VULKAN_HPP_NAMESPACE::StencilOp failOp, VULKAN_HPP_NAMESPACE::StencilOp passOp, VULKAN_HPP_NAMESPACE::StencilOp depthFailOp, VULKAN_HPP_NAMESPACE::CompareOp compareOp, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4668
4669
4670 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4671 void setRasterizerDiscardEnable( VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4672
4673
4674 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4675 void setDepthBiasEnable( VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4676
4677
4678 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4679 void setPrimitiveRestartEnable( VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4680
4681 //=== VK_EXT_debug_marker ===
4682
4683
4684 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4685 void debugMarkerBeginEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT * pMarkerInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4686 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4687 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4688 void debugMarkerBeginEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT & markerInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4689 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4690
4691
4692 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4693 void debugMarkerEndEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4694
4695
4696 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4697 void debugMarkerInsertEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT * pMarkerInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4698 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4699 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4700 void debugMarkerInsertEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT & markerInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4701 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4702
4703 //=== VK_KHR_video_queue ===
4704
4705
4706 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4707 void beginVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR * pBeginInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4708 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4709 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4710 void beginVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR & beginInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4711 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4712
4713
4714 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4715 void endVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR * pEndCodingInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4716 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4717 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4718 void endVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR & endCodingInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4719 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4720
4721
4722 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4723 void controlVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR * pCodingControlInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4724 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4725 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4726 void controlVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR & codingControlInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4727 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4728
4729 //=== VK_KHR_video_decode_queue ===
4730
4731
4732 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4733 void decodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR * pDecodeInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4734 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4735 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4736 void decodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR & decodeInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4737 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4738
4739 //=== VK_EXT_transform_feedback ===
4740
4741
4742 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4743 void bindTransformFeedbackBuffersEXT( uint32_t firstBinding, uint32_t bindingCount, const VULKAN_HPP_NAMESPACE::Buffer * pBuffers, const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets, const VULKAN_HPP_NAMESPACE::DeviceSize * pSizes, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4744 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4745 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4746 void bindTransformFeedbackBuffersEXT( uint32_t firstBinding, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
4747 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4748
4749
4750 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4751 void beginTransformFeedbackEXT( uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VULKAN_HPP_NAMESPACE::Buffer * pCounterBuffers, const VULKAN_HPP_NAMESPACE::DeviceSize * pCounterBufferOffsets, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4752 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4753 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4754 void beginTransformFeedbackEXT( uint32_t firstCounterBuffer, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & counterBuffers, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
4755 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4756
4757
4758 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4759 void endTransformFeedbackEXT( uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VULKAN_HPP_NAMESPACE::Buffer * pCounterBuffers, const VULKAN_HPP_NAMESPACE::DeviceSize * pCounterBufferOffsets, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4760 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4761 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4762 void endTransformFeedbackEXT( uint32_t firstCounterBuffer, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & counterBuffers, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
4763 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4764
4765
4766 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4767 void beginQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query, VULKAN_HPP_NAMESPACE::QueryControlFlags flags, uint32_t index, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4768
4769
4770 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4771 void endQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query, uint32_t index, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4772
4773
4774 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4775 void drawIndirectByteCountEXT( uint32_t instanceCount, uint32_t firstInstance, VULKAN_HPP_NAMESPACE::Buffer counterBuffer, VULKAN_HPP_NAMESPACE::DeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4776
4777 //=== VK_NVX_binary_import ===
4778
4779
4780 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4781 void cuLaunchKernelNVX( const VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX * pLaunchInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4782 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4783 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4784 void cuLaunchKernelNVX( const VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX & launchInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4785 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4786
4787 //=== VK_AMD_draw_indirect_count ===
4788
4789
4790 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4791 void drawIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::Buffer countBuffer, VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4792
4793
4794 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4795 void drawIndexedIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::Buffer countBuffer, VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4796
4797 //=== VK_KHR_dynamic_rendering ===
4798
4799
4800 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4801 void beginRenderingKHR( const VULKAN_HPP_NAMESPACE::RenderingInfo * pRenderingInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4802 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4803 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4804 void beginRenderingKHR( const VULKAN_HPP_NAMESPACE::RenderingInfo & renderingInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4805 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4806
4807
4808 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4809 void endRenderingKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4810
4811 //=== VK_KHR_device_group ===
4812
4813
4814 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4815 void setDeviceMaskKHR( uint32_t deviceMask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4816
4817
4818 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4819 void dispatchBaseKHR( uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4820
4821 //=== VK_KHR_push_descriptor ===
4822
4823
4824 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4825 void pushDescriptorSetKHR( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, VULKAN_HPP_NAMESPACE::PipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VULKAN_HPP_NAMESPACE::WriteDescriptorSet * pDescriptorWrites, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4826 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4827 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4828 void pushDescriptorSetKHR( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, VULKAN_HPP_NAMESPACE::PipelineLayout layout, uint32_t set, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4829 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4830
4831
4832 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4833 void pushDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, VULKAN_HPP_NAMESPACE::PipelineLayout layout, uint32_t set, const void * pData, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4834 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4835 template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4836 void pushDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, VULKAN_HPP_NAMESPACE::PipelineLayout layout, uint32_t set, DataType const & data, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4837 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4838
4839 //=== VK_EXT_conditional_rendering ===
4840
4841
4842 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4843 void beginConditionalRenderingEXT( const VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT * pConditionalRenderingBegin, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4844 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4845 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4846 void beginConditionalRenderingEXT( const VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT & conditionalRenderingBegin, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4847 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4848
4849
4850 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4851 void endConditionalRenderingEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4852
4853 //=== VK_NV_clip_space_w_scaling ===
4854
4855
4856 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4857 void setViewportWScalingNV( uint32_t firstViewport, uint32_t viewportCount, const VULKAN_HPP_NAMESPACE::ViewportWScalingNV * pViewportWScalings, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4858 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4859 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4860 void setViewportWScalingNV( uint32_t firstViewport, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ViewportWScalingNV> const & viewportWScalings, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4861 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4862
4863 //=== VK_EXT_discard_rectangles ===
4864
4865
4866 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4867 void setDiscardRectangleEXT( uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VULKAN_HPP_NAMESPACE::Rect2D * pDiscardRectangles, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4868 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4869 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4870 void setDiscardRectangleEXT( uint32_t firstDiscardRectangle, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & discardRectangles, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4871 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4872
4873
4874 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4875 void setDiscardRectangleEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 discardRectangleEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4876
4877
4878 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4879 void setDiscardRectangleModeEXT( VULKAN_HPP_NAMESPACE::DiscardRectangleModeEXT discardRectangleMode, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4880
4881 //=== VK_KHR_create_renderpass2 ===
4882
4883
4884 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4885 void beginRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo * pRenderPassBegin, const VULKAN_HPP_NAMESPACE::SubpassBeginInfo * pSubpassBeginInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4886 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4887 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4888 void beginRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin, const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4889 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4890
4891
4892 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4893 void nextSubpass2KHR( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo * pSubpassBeginInfo, const VULKAN_HPP_NAMESPACE::SubpassEndInfo * pSubpassEndInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4894 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4895 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4896 void nextSubpass2KHR( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo, const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4897 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4898
4899
4900 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4901 void endRenderPass2KHR( const VULKAN_HPP_NAMESPACE::SubpassEndInfo * pSubpassEndInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4902 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4903 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4904 void endRenderPass2KHR( const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4905 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4906
4907 //=== VK_EXT_debug_utils ===
4908
4909
4910 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4911 void beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4912 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4913 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4914 void beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4915 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4916
4917
4918 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4919 void endDebugUtilsLabelEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4920
4921
4922 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4923 void insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4924 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4925 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4926 void insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4927 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4928
4929 #if defined( VK_ENABLE_BETA_EXTENSIONS )
4930 //=== VK_AMDX_shader_enqueue ===
4931
4932
4933 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4934 void initializeGraphScratchMemoryAMDX( VULKAN_HPP_NAMESPACE::DeviceAddress scratch, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4935
4936
4937 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4938 void dispatchGraphAMDX( VULKAN_HPP_NAMESPACE::DeviceAddress scratch, const VULKAN_HPP_NAMESPACE::DispatchGraphCountInfoAMDX * pCountInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4939 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4940 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4941 void dispatchGraphAMDX( VULKAN_HPP_NAMESPACE::DeviceAddress scratch, const VULKAN_HPP_NAMESPACE::DispatchGraphCountInfoAMDX & countInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4942 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4943
4944
4945 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4946 void dispatchGraphIndirectAMDX( VULKAN_HPP_NAMESPACE::DeviceAddress scratch, const VULKAN_HPP_NAMESPACE::DispatchGraphCountInfoAMDX * pCountInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4947 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4948 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4949 void dispatchGraphIndirectAMDX( VULKAN_HPP_NAMESPACE::DeviceAddress scratch, const VULKAN_HPP_NAMESPACE::DispatchGraphCountInfoAMDX & countInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4950 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4951
4952
4953 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4954 void dispatchGraphIndirectCountAMDX( VULKAN_HPP_NAMESPACE::DeviceAddress scratch, VULKAN_HPP_NAMESPACE::DeviceAddress countInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4955 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
4956
4957 //=== VK_EXT_sample_locations ===
4958
4959
4960 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4961 void setSampleLocationsEXT( const VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT * pSampleLocationsInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4962 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4963 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4964 void setSampleLocationsEXT( const VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT & sampleLocationsInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4965 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4966
4967 //=== VK_KHR_acceleration_structure ===
4968
4969
4970 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4971 void buildAccelerationStructuresKHR( uint32_t infoCount, const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR * pInfos, const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4972 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4973 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4974 void buildAccelerationStructuresKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const> const & pBuildRangeInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
4975 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4976
4977
4978 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4979 void buildAccelerationStructuresIndirectKHR( uint32_t infoCount, const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR * pInfos, const VULKAN_HPP_NAMESPACE::DeviceAddress * pIndirectDeviceAddresses, const uint32_t * pIndirectStrides, const uint32_t * const * ppMaxPrimitiveCounts, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4980 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4981 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4982 void buildAccelerationStructuresIndirectKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceAddress> const & indirectDeviceAddresses, VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t> const & indirectStrides, VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t * const> const & pMaxPrimitiveCounts, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
4983 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4984
4985
4986 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4987 void copyAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR * pInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4988 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4989 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4990 void copyAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4991 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4992
4993
4994 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4995 void copyAccelerationStructureToMemoryKHR( const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR * pInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4996 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4997 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4998 void copyAccelerationStructureToMemoryKHR( const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4999 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5000
5001
5002 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5003 void copyMemoryToAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR * pInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5004 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5005 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5006 void copyMemoryToAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5007 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5008
5009
5010 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5011 void writeAccelerationStructuresPropertiesKHR( uint32_t accelerationStructureCount, const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR * pAccelerationStructures, VULKAN_HPP_NAMESPACE::QueryType queryType, VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5012 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5013 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5014 void writeAccelerationStructuresPropertiesKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures, VULKAN_HPP_NAMESPACE::QueryType queryType, VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5015 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5016
5017 //=== VK_KHR_ray_tracing_pipeline ===
5018
5019
5020 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5021 void traceRaysKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pRaygenShaderBindingTable, const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pMissShaderBindingTable, const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pHitShaderBindingTable, const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pCallableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5022 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5023 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5024 void traceRaysKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & raygenShaderBindingTable, const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & missShaderBindingTable, const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & hitShaderBindingTable, const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & callableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5025 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5026
5027
5028 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5029 void traceRaysIndirectKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pRaygenShaderBindingTable, const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pMissShaderBindingTable, const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pHitShaderBindingTable, const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pCallableShaderBindingTable, VULKAN_HPP_NAMESPACE::DeviceAddress indirectDeviceAddress, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5030 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5031 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5032 void traceRaysIndirectKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & raygenShaderBindingTable, const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & missShaderBindingTable, const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & hitShaderBindingTable, const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & callableShaderBindingTable, VULKAN_HPP_NAMESPACE::DeviceAddress indirectDeviceAddress, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5033 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5034
5035
5036 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5037 void setRayTracingPipelineStackSizeKHR( uint32_t pipelineStackSize, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5038
5039 //=== VK_NV_shading_rate_image ===
5040
5041
5042 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5043 void bindShadingRateImageNV( VULKAN_HPP_NAMESPACE::ImageView imageView, VULKAN_HPP_NAMESPACE::ImageLayout imageLayout, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5044
5045
5046 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5047 void setViewportShadingRatePaletteNV( uint32_t firstViewport, uint32_t viewportCount, const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV * pShadingRatePalettes, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5048 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5049 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5050 void setViewportShadingRatePaletteNV( uint32_t firstViewport, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV> const & shadingRatePalettes, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5051 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5052
5053
5054 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5055 void setCoarseSampleOrderNV( VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV * pCustomSampleOrders, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5056 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5057 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5058 void setCoarseSampleOrderNV( VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV sampleOrderType, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV> const & customSampleOrders, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5059 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5060
5061 //=== VK_NV_ray_tracing ===
5062
5063
5064 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5065 void buildAccelerationStructureNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV * pInfo, VULKAN_HPP_NAMESPACE::Buffer instanceData, VULKAN_HPP_NAMESPACE::DeviceSize instanceOffset, VULKAN_HPP_NAMESPACE::Bool32 update, VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst, VULKAN_HPP_NAMESPACE::AccelerationStructureNV src, VULKAN_HPP_NAMESPACE::Buffer scratch, VULKAN_HPP_NAMESPACE::DeviceSize scratchOffset, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5066 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5067 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5068 void buildAccelerationStructureNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV & info, VULKAN_HPP_NAMESPACE::Buffer instanceData, VULKAN_HPP_NAMESPACE::DeviceSize instanceOffset, VULKAN_HPP_NAMESPACE::Bool32 update, VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst, VULKAN_HPP_NAMESPACE::AccelerationStructureNV src, VULKAN_HPP_NAMESPACE::Buffer scratch, VULKAN_HPP_NAMESPACE::DeviceSize scratchOffset, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5069 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5070
5071
5072 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5073 void copyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst, VULKAN_HPP_NAMESPACE::AccelerationStructureNV src, VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR mode, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5074
5075
5076 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5077 void traceRaysNV( VULKAN_HPP_NAMESPACE::Buffer raygenShaderBindingTableBuffer, VULKAN_HPP_NAMESPACE::DeviceSize raygenShaderBindingOffset, VULKAN_HPP_NAMESPACE::Buffer missShaderBindingTableBuffer, VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingOffset, VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingStride, VULKAN_HPP_NAMESPACE::Buffer hitShaderBindingTableBuffer, VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingOffset, VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingStride, VULKAN_HPP_NAMESPACE::Buffer callableShaderBindingTableBuffer, VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingOffset, VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5078
5079
5080 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5081 void writeAccelerationStructuresPropertiesNV( uint32_t accelerationStructureCount, const VULKAN_HPP_NAMESPACE::AccelerationStructureNV * pAccelerationStructures, VULKAN_HPP_NAMESPACE::QueryType queryType, VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5082 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5083 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5084 void writeAccelerationStructuresPropertiesNV( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureNV> const & accelerationStructures, VULKAN_HPP_NAMESPACE::QueryType queryType, VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5085 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5086
5087 //=== VK_KHR_draw_indirect_count ===
5088
5089
5090 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5091 void drawIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::Buffer countBuffer, VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5092
5093
5094 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5095 void drawIndexedIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::Buffer countBuffer, VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5096
5097 //=== VK_AMD_buffer_marker ===
5098
5099
5100 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5101 void writeBufferMarkerAMD( VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage, VULKAN_HPP_NAMESPACE::Buffer dstBuffer, VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, uint32_t marker, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5102
5103 //=== VK_NV_mesh_shader ===
5104
5105
5106 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5107 void drawMeshTasksNV( uint32_t taskCount, uint32_t firstTask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5108
5109
5110 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5111 void drawMeshTasksIndirectNV( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5112
5113
5114 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5115 void drawMeshTasksIndirectCountNV( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::Buffer countBuffer, VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5116
5117 //=== VK_NV_scissor_exclusive ===
5118
5119
5120 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5121 void setExclusiveScissorEnableNV( uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VULKAN_HPP_NAMESPACE::Bool32 * pExclusiveScissorEnables, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5122 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5123 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5124 void setExclusiveScissorEnableNV( uint32_t firstExclusiveScissor, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & exclusiveScissorEnables, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5125 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5126
5127
5128 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5129 void setExclusiveScissorNV( uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VULKAN_HPP_NAMESPACE::Rect2D * pExclusiveScissors, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5130 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5131 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5132 void setExclusiveScissorNV( uint32_t firstExclusiveScissor, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & exclusiveScissors, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5133 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5134
5135 //=== VK_NV_device_diagnostic_checkpoints ===
5136
5137
5138 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5139 void setCheckpointNV( const void * pCheckpointMarker, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5140 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5141 template <typename CheckpointMarkerType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5142 void setCheckpointNV( CheckpointMarkerType const & checkpointMarker, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5143 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5144
5145 //=== VK_INTEL_performance_query ===
5146
5147
5148 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5149 VULKAN_HPP_NODISCARD Result setPerformanceMarkerINTEL( const VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL * pMarkerInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5150 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5151 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5152 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type setPerformanceMarkerINTEL( const VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL & markerInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
5153 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5154
5155
5156 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5157 VULKAN_HPP_NODISCARD Result setPerformanceStreamMarkerINTEL( const VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL * pMarkerInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5158 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5159 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5160 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type setPerformanceStreamMarkerINTEL( const VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL & markerInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
5161 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5162
5163
5164 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5165 VULKAN_HPP_NODISCARD Result setPerformanceOverrideINTEL( const VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL * pOverrideInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5166 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5167 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5168 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type setPerformanceOverrideINTEL( const VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL & overrideInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
5169 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5170
5171 //=== VK_KHR_fragment_shading_rate ===
5172
5173
5174 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5175 void setFragmentShadingRateKHR( const VULKAN_HPP_NAMESPACE::Extent2D * pFragmentSize, const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2], Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5176 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5177 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5178 void setFragmentShadingRateKHR( const VULKAN_HPP_NAMESPACE::Extent2D & fragmentSize, const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2], Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5179 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5180
5181 //=== VK_EXT_line_rasterization ===
5182
5183
5184 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5185 void setLineStippleEXT( uint32_t lineStippleFactor, uint16_t lineStipplePattern, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5186
5187 //=== VK_EXT_extended_dynamic_state ===
5188
5189
5190 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5191 void setCullModeEXT( VULKAN_HPP_NAMESPACE::CullModeFlags cullMode, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5192
5193
5194 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5195 void setFrontFaceEXT( VULKAN_HPP_NAMESPACE::FrontFace frontFace, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5196
5197
5198 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5199 void setPrimitiveTopologyEXT( VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5200
5201
5202 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5203 void setViewportWithCountEXT( uint32_t viewportCount, const VULKAN_HPP_NAMESPACE::Viewport * pViewports, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5204 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5205 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5206 void setViewportWithCountEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5207 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5208
5209
5210 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5211 void setScissorWithCountEXT( uint32_t scissorCount, const VULKAN_HPP_NAMESPACE::Rect2D * pScissors, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5212 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5213 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5214 void setScissorWithCountEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5215 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5216
5217
5218 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5219 void bindVertexBuffers2EXT( uint32_t firstBinding, uint32_t bindingCount, const VULKAN_HPP_NAMESPACE::Buffer * pBuffers, const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets, const VULKAN_HPP_NAMESPACE::DeviceSize * pSizes, const VULKAN_HPP_NAMESPACE::DeviceSize * pStrides, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5220 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5221 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5222 void bindVertexBuffers2EXT( uint32_t firstBinding, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & strides VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
5223 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5224
5225
5226 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5227 void setDepthTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5228
5229
5230 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5231 void setDepthWriteEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5232
5233
5234 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5235 void setDepthCompareOpEXT( VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5236
5237
5238 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5239 void setDepthBoundsTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5240
5241
5242 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5243 void setStencilTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5244
5245
5246 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5247 void setStencilOpEXT( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, VULKAN_HPP_NAMESPACE::StencilOp failOp, VULKAN_HPP_NAMESPACE::StencilOp passOp, VULKAN_HPP_NAMESPACE::StencilOp depthFailOp, VULKAN_HPP_NAMESPACE::CompareOp compareOp, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5248
5249 //=== VK_NV_device_generated_commands ===
5250
5251
5252 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5253 void preprocessGeneratedCommandsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV * pGeneratedCommandsInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5254 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5255 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5256 void preprocessGeneratedCommandsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV & generatedCommandsInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5257 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5258
5259
5260 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5261 void executeGeneratedCommandsNV( VULKAN_HPP_NAMESPACE::Bool32 isPreprocessed, const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV * pGeneratedCommandsInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5262 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5263 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5264 void executeGeneratedCommandsNV( VULKAN_HPP_NAMESPACE::Bool32 isPreprocessed, const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV & generatedCommandsInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5265 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5266
5267
5268 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5269 void bindPipelineShaderGroupNV( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t groupIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5270
5271 //=== VK_EXT_depth_bias_control ===
5272
5273
5274 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5275 void setDepthBias2EXT( const VULKAN_HPP_NAMESPACE::DepthBiasInfoEXT * pDepthBiasInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5276 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5277 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5278 void setDepthBias2EXT( const VULKAN_HPP_NAMESPACE::DepthBiasInfoEXT & depthBiasInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5279 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5280
5281 #if defined( VK_ENABLE_BETA_EXTENSIONS )
5282 //=== VK_KHR_video_encode_queue ===
5283
5284
5285 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5286 void encodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR * pEncodeInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5287 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5288 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5289 void encodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR & encodeInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5290 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5291 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
5292
5293 //=== VK_KHR_synchronization2 ===
5294
5295
5296 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5297 void setEvent2KHR( VULKAN_HPP_NAMESPACE::Event event, const VULKAN_HPP_NAMESPACE::DependencyInfo * pDependencyInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5298 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5299 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5300 void setEvent2KHR( VULKAN_HPP_NAMESPACE::Event event, const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5301 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5302
5303
5304 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5305 void resetEvent2KHR( VULKAN_HPP_NAMESPACE::Event event, VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stageMask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5306
5307
5308 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5309 void waitEvents2KHR( uint32_t eventCount, const VULKAN_HPP_NAMESPACE::Event * pEvents, const VULKAN_HPP_NAMESPACE::DependencyInfo * pDependencyInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5310 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5311 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5312 void waitEvents2KHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const & events, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DependencyInfo> const & dependencyInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
5313 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5314
5315
5316 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5317 void pipelineBarrier2KHR( const VULKAN_HPP_NAMESPACE::DependencyInfo * pDependencyInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5318 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5319 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5320 void pipelineBarrier2KHR( const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5321 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5322
5323
5324 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5325 void writeTimestamp2KHR( VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stage, VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5326
5327
5328 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5329 void writeBufferMarker2AMD( VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stage, VULKAN_HPP_NAMESPACE::Buffer dstBuffer, VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, uint32_t marker, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5330
5331 //=== VK_EXT_descriptor_buffer ===
5332
5333
5334 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5335 void bindDescriptorBuffersEXT( uint32_t bufferCount, const VULKAN_HPP_NAMESPACE::DescriptorBufferBindingInfoEXT * pBindingInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5336 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5337 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5338 void bindDescriptorBuffersEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorBufferBindingInfoEXT> const & bindingInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5339 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5340
5341
5342 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5343 void setDescriptorBufferOffsetsEXT( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, VULKAN_HPP_NAMESPACE::PipelineLayout layout, uint32_t firstSet, uint32_t setCount, const uint32_t * pBufferIndices, const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5344 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5345 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5346 void setDescriptorBufferOffsetsEXT( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, VULKAN_HPP_NAMESPACE::PipelineLayout layout, uint32_t firstSet, VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t> const & bufferIndices, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
5347 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5348
5349
5350 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5351 void bindDescriptorBufferEmbeddedSamplersEXT( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, VULKAN_HPP_NAMESPACE::PipelineLayout layout, uint32_t set, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5352
5353 //=== VK_NV_fragment_shading_rate_enums ===
5354
5355
5356 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5357 void setFragmentShadingRateEnumNV( VULKAN_HPP_NAMESPACE::FragmentShadingRateNV shadingRate, const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2], Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5358
5359 //=== VK_EXT_mesh_shader ===
5360
5361
5362 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5363 void drawMeshTasksEXT( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5364
5365
5366 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5367 void drawMeshTasksIndirectEXT( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5368
5369
5370 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5371 void drawMeshTasksIndirectCountEXT( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::Buffer countBuffer, VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5372
5373 //=== VK_KHR_copy_commands2 ===
5374
5375
5376 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5377 void copyBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 * pCopyBufferInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5378 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5379 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5380 void copyBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 & copyBufferInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5381 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5382
5383
5384 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5385 void copyImage2KHR( const VULKAN_HPP_NAMESPACE::CopyImageInfo2 * pCopyImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5386 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5387 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5388 void copyImage2KHR( const VULKAN_HPP_NAMESPACE::CopyImageInfo2 & copyImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5389 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5390
5391
5392 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5393 void copyBufferToImage2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 * pCopyBufferToImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5394 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5395 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5396 void copyBufferToImage2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 & copyBufferToImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5397 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5398
5399
5400 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5401 void copyImageToBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 * pCopyImageToBufferInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5402 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5403 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5404 void copyImageToBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 & copyImageToBufferInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5405 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5406
5407
5408 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5409 void blitImage2KHR( const VULKAN_HPP_NAMESPACE::BlitImageInfo2 * pBlitImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5410 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5411 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5412 void blitImage2KHR( const VULKAN_HPP_NAMESPACE::BlitImageInfo2 & blitImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5413 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5414
5415
5416 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5417 void resolveImage2KHR( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 * pResolveImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5418 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5419 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5420 void resolveImage2KHR( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 & resolveImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5421 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5422
5423 //=== VK_EXT_vertex_input_dynamic_state ===
5424
5425
5426 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5427 void setVertexInputEXT( uint32_t vertexBindingDescriptionCount, const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT * pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT * pVertexAttributeDescriptions, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5428 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5429 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5430 void setVertexInputEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT> const & vertexBindingDescriptions, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT> const & vertexAttributeDescriptions, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5431 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5432
5433 //=== VK_HUAWEI_subpass_shading ===
5434
5435
5436 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5437 void subpassShadingHUAWEI( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5438
5439 //=== VK_HUAWEI_invocation_mask ===
5440
5441
5442 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5443 void bindInvocationMaskHUAWEI( VULKAN_HPP_NAMESPACE::ImageView imageView, VULKAN_HPP_NAMESPACE::ImageLayout imageLayout, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5444
5445 //=== VK_EXT_extended_dynamic_state2 ===
5446
5447
5448 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5449 void setPatchControlPointsEXT( uint32_t patchControlPoints, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5450
5451
5452 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5453 void setRasterizerDiscardEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5454
5455
5456 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5457 void setDepthBiasEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5458
5459
5460 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5461 void setLogicOpEXT( VULKAN_HPP_NAMESPACE::LogicOp logicOp, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5462
5463
5464 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5465 void setPrimitiveRestartEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5466
5467 //=== VK_EXT_color_write_enable ===
5468
5469
5470 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5471 void setColorWriteEnableEXT( uint32_t attachmentCount, const VULKAN_HPP_NAMESPACE::Bool32 * pColorWriteEnables, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5472 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5473 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5474 void setColorWriteEnableEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & colorWriteEnables, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5475 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5476
5477 //=== VK_KHR_ray_tracing_maintenance1 ===
5478
5479
5480 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5481 void traceRaysIndirect2KHR( VULKAN_HPP_NAMESPACE::DeviceAddress indirectDeviceAddress, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5482
5483 //=== VK_EXT_multi_draw ===
5484
5485
5486 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5487 void drawMultiEXT( uint32_t drawCount, const VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT * pVertexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5488 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5489 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5490 void drawMultiEXT( VULKAN_HPP_NAMESPACE::StridedArrayProxy<const VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT> const & vertexInfo, uint32_t instanceCount, uint32_t firstInstance, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5491 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5492
5493
5494 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5495 void drawMultiIndexedEXT( uint32_t drawCount, const VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT * pIndexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, const int32_t * pVertexOffset, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5496 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5497 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5498 void drawMultiIndexedEXT( VULKAN_HPP_NAMESPACE::StridedArrayProxy<const VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT> const & indexInfo, uint32_t instanceCount, uint32_t firstInstance, Optional<const int32_t> vertexOffset VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5499 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5500
5501 //=== VK_EXT_opacity_micromap ===
5502
5503
5504 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5505 void buildMicromapsEXT( uint32_t infoCount, const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT * pInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5506 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5507 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5508 void buildMicromapsEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT> const & infos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5509 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5510
5511
5512 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5513 void copyMicromapEXT( const VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT * pInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5514 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5515 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5516 void copyMicromapEXT( const VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5517 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5518
5519
5520 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5521 void copyMicromapToMemoryEXT( const VULKAN_HPP_NAMESPACE::CopyMicromapToMemoryInfoEXT * pInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5522 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5523 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5524 void copyMicromapToMemoryEXT( const VULKAN_HPP_NAMESPACE::CopyMicromapToMemoryInfoEXT & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5525 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5526
5527
5528 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5529 void copyMemoryToMicromapEXT( const VULKAN_HPP_NAMESPACE::CopyMemoryToMicromapInfoEXT * pInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5530 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5531 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5532 void copyMemoryToMicromapEXT( const VULKAN_HPP_NAMESPACE::CopyMemoryToMicromapInfoEXT & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5533 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5534
5535
5536 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5537 void writeMicromapsPropertiesEXT( uint32_t micromapCount, const VULKAN_HPP_NAMESPACE::MicromapEXT * pMicromaps, VULKAN_HPP_NAMESPACE::QueryType queryType, VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5538 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5539 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5540 void writeMicromapsPropertiesEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapEXT> const & micromaps, VULKAN_HPP_NAMESPACE::QueryType queryType, VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5541 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5542
5543 //=== VK_HUAWEI_cluster_culling_shader ===
5544
5545
5546 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5547 void drawClusterHUAWEI( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5548
5549
5550 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5551 void drawClusterIndirectHUAWEI( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5552
5553 //=== VK_NV_copy_memory_indirect ===
5554
5555
5556 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5557 void copyMemoryIndirectNV( VULKAN_HPP_NAMESPACE::DeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5558
5559
5560 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5561 void copyMemoryToImageIndirectNV( VULKAN_HPP_NAMESPACE::DeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride, VULKAN_HPP_NAMESPACE::Image dstImage, VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, const VULKAN_HPP_NAMESPACE::ImageSubresourceLayers * pImageSubresources, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5562 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5563 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5564 void copyMemoryToImageIndirectNV( VULKAN_HPP_NAMESPACE::DeviceAddress copyBufferAddress, uint32_t stride, VULKAN_HPP_NAMESPACE::Image dstImage, VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceLayers> const & imageSubresources, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5565 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5566
5567 //=== VK_NV_memory_decompression ===
5568
5569
5570 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5571 void decompressMemoryNV( uint32_t decompressRegionCount, const VULKAN_HPP_NAMESPACE::DecompressMemoryRegionNV * pDecompressMemoryRegions, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5572 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5573 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5574 void decompressMemoryNV( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DecompressMemoryRegionNV> const & decompressMemoryRegions, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5575 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5576
5577
5578 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5579 void decompressMemoryIndirectCountNV( VULKAN_HPP_NAMESPACE::DeviceAddress indirectCommandsAddress, VULKAN_HPP_NAMESPACE::DeviceAddress indirectCommandsCountAddress, uint32_t stride, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5580
5581 //=== VK_NV_device_generated_commands_compute ===
5582
5583
5584 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5585 void updatePipelineIndirectBufferNV( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, VULKAN_HPP_NAMESPACE::Pipeline pipeline, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5586
5587 //=== VK_EXT_extended_dynamic_state3 ===
5588
5589
5590 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5591 void setTessellationDomainOriginEXT( VULKAN_HPP_NAMESPACE::TessellationDomainOrigin domainOrigin, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5592
5593
5594 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5595 void setDepthClampEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthClampEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5596
5597
5598 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5599 void setPolygonModeEXT( VULKAN_HPP_NAMESPACE::PolygonMode polygonMode, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5600
5601
5602 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5603 void setRasterizationSamplesEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits rasterizationSamples, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5604
5605
5606 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5607 void setSampleMaskEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples, const VULKAN_HPP_NAMESPACE::SampleMask * pSampleMask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5608 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5609 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5610 void setSampleMaskEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SampleMask> const & sampleMask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
5611 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5612
5613
5614 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5615 void setAlphaToCoverageEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 alphaToCoverageEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5616
5617
5618 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5619 void setAlphaToOneEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 alphaToOneEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5620
5621
5622 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5623 void setLogicOpEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 logicOpEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5624
5625
5626 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5627 void setColorBlendEnableEXT( uint32_t firstAttachment, uint32_t attachmentCount, const VULKAN_HPP_NAMESPACE::Bool32 * pColorBlendEnables, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5628 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5629 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5630 void setColorBlendEnableEXT( uint32_t firstAttachment, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & colorBlendEnables, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5631 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5632
5633
5634 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5635 void setColorBlendEquationEXT( uint32_t firstAttachment, uint32_t attachmentCount, const VULKAN_HPP_NAMESPACE::ColorBlendEquationEXT * pColorBlendEquations, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5636 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5637 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5638 void setColorBlendEquationEXT( uint32_t firstAttachment, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ColorBlendEquationEXT> const & colorBlendEquations, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5639 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5640
5641
5642 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5643 void setColorWriteMaskEXT( uint32_t firstAttachment, uint32_t attachmentCount, const VULKAN_HPP_NAMESPACE::ColorComponentFlags * pColorWriteMasks, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5644 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5645 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5646 void setColorWriteMaskEXT( uint32_t firstAttachment, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ColorComponentFlags> const & colorWriteMasks, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5647 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5648
5649
5650 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5651 void setRasterizationStreamEXT( uint32_t rasterizationStream, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5652
5653
5654 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5655 void setConservativeRasterizationModeEXT( VULKAN_HPP_NAMESPACE::ConservativeRasterizationModeEXT conservativeRasterizationMode, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5656
5657
5658 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5659 void setExtraPrimitiveOverestimationSizeEXT( float extraPrimitiveOverestimationSize, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5660
5661
5662 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5663 void setDepthClipEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthClipEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5664
5665
5666 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5667 void setSampleLocationsEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 sampleLocationsEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5668
5669
5670 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5671 void setColorBlendAdvancedEXT( uint32_t firstAttachment, uint32_t attachmentCount, const VULKAN_HPP_NAMESPACE::ColorBlendAdvancedEXT * pColorBlendAdvanced, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5672 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5673 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5674 void setColorBlendAdvancedEXT( uint32_t firstAttachment, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ColorBlendAdvancedEXT> const & colorBlendAdvanced, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5675 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5676
5677
5678 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5679 void setProvokingVertexModeEXT( VULKAN_HPP_NAMESPACE::ProvokingVertexModeEXT provokingVertexMode, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5680
5681
5682 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5683 void setLineRasterizationModeEXT( VULKAN_HPP_NAMESPACE::LineRasterizationModeEXT lineRasterizationMode, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5684
5685
5686 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5687 void setLineStippleEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 stippledLineEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5688
5689
5690 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5691 void setDepthClipNegativeOneToOneEXT( VULKAN_HPP_NAMESPACE::Bool32 negativeOneToOne, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5692
5693
5694 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5695 void setViewportWScalingEnableNV( VULKAN_HPP_NAMESPACE::Bool32 viewportWScalingEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5696
5697
5698 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5699 void setViewportSwizzleNV( uint32_t firstViewport, uint32_t viewportCount, const VULKAN_HPP_NAMESPACE::ViewportSwizzleNV * pViewportSwizzles, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5700 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5701 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5702 void setViewportSwizzleNV( uint32_t firstViewport, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ViewportSwizzleNV> const & viewportSwizzles, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5703 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5704
5705
5706 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5707 void setCoverageToColorEnableNV( VULKAN_HPP_NAMESPACE::Bool32 coverageToColorEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5708
5709
5710 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5711 void setCoverageToColorLocationNV( uint32_t coverageToColorLocation, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5712
5713
5714 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5715 void setCoverageModulationModeNV( VULKAN_HPP_NAMESPACE::CoverageModulationModeNV coverageModulationMode, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5716
5717
5718 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5719 void setCoverageModulationTableEnableNV( VULKAN_HPP_NAMESPACE::Bool32 coverageModulationTableEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5720
5721
5722 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5723 void setCoverageModulationTableNV( uint32_t coverageModulationTableCount, const float * pCoverageModulationTable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5724 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5725 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5726 void setCoverageModulationTableNV( VULKAN_HPP_NAMESPACE::ArrayProxy<const float> const & coverageModulationTable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5727 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5728
5729
5730 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5731 void setShadingRateImageEnableNV( VULKAN_HPP_NAMESPACE::Bool32 shadingRateImageEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5732
5733
5734 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5735 void setRepresentativeFragmentTestEnableNV( VULKAN_HPP_NAMESPACE::Bool32 representativeFragmentTestEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5736
5737
5738 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5739 void setCoverageReductionModeNV( VULKAN_HPP_NAMESPACE::CoverageReductionModeNV coverageReductionMode, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5740
5741 //=== VK_NV_optical_flow ===
5742
5743
5744 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5745 void opticalFlowExecuteNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session, const VULKAN_HPP_NAMESPACE::OpticalFlowExecuteInfoNV * pExecuteInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5746 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5747 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5748 void opticalFlowExecuteNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session, const VULKAN_HPP_NAMESPACE::OpticalFlowExecuteInfoNV & executeInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5749 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5750
5751 //=== VK_KHR_maintenance5 ===
5752
5753
5754 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5755 void bindIndexBuffer2KHR( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::DeviceSize size, VULKAN_HPP_NAMESPACE::IndexType indexType, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5756
5757 //=== VK_EXT_shader_object ===
5758
5759
5760 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5761 void bindShadersEXT( uint32_t stageCount, const VULKAN_HPP_NAMESPACE::ShaderStageFlagBits * pStages, const VULKAN_HPP_NAMESPACE::ShaderEXT * pShaders, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5762 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5763 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5764 void bindShadersEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShaderStageFlagBits> const & stages, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShaderEXT> const & shaders, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
5765 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5766
5767 //=== VK_EXT_attachment_feedback_loop_dynamic_state ===
5768
5769
5770 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5771 void setAttachmentFeedbackLoopEnableEXT( VULKAN_HPP_NAMESPACE::ImageAspectFlags aspectMask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5772
operator VkCommandBuffer() const5773 operator VkCommandBuffer() const VULKAN_HPP_NOEXCEPT
5774 {
5775 return m_commandBuffer;
5776 }
5777
operator bool() const5778 explicit operator bool() const VULKAN_HPP_NOEXCEPT
5779 {
5780 return m_commandBuffer != VK_NULL_HANDLE;
5781 }
5782
operator !() const5783 bool operator!() const VULKAN_HPP_NOEXCEPT
5784 {
5785 return m_commandBuffer == VK_NULL_HANDLE;
5786 }
5787
5788 private:
5789 VkCommandBuffer m_commandBuffer = {};
5790 };
5791
5792 template <>
5793 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCommandBuffer>
5794 {
5795 using Type = VULKAN_HPP_NAMESPACE::CommandBuffer;
5796 };
5797
5798
5799 template <>
5800 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandBuffer>
5801 {
5802 using Type = VULKAN_HPP_NAMESPACE::CommandBuffer;
5803 };
5804
5805
5806 template <>
5807 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CommandBuffer>
5808 {
5809 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
5810 };
5811
5812 class DeviceMemory
5813 {
5814 public:
5815 using CType = VkDeviceMemory;
5816 using NativeType = VkDeviceMemory;
5817
5818 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDeviceMemory;
5819 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDeviceMemory;
5820
5821 public:
5822 VULKAN_HPP_CONSTEXPR DeviceMemory() = default;
DeviceMemory(std::nullptr_t)5823 VULKAN_HPP_CONSTEXPR DeviceMemory( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5824 {}
DeviceMemory(VkDeviceMemory deviceMemory)5825 VULKAN_HPP_TYPESAFE_EXPLICIT DeviceMemory( VkDeviceMemory deviceMemory ) VULKAN_HPP_NOEXCEPT
5826 : m_deviceMemory( deviceMemory )
5827 {}
5828
5829 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkDeviceMemory deviceMemory)5830 DeviceMemory & operator=(VkDeviceMemory deviceMemory) VULKAN_HPP_NOEXCEPT
5831 {
5832 m_deviceMemory = deviceMemory;
5833 return *this;
5834 }
5835 #endif
5836
operator =(std::nullptr_t)5837 DeviceMemory & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5838 {
5839 m_deviceMemory = {};
5840 return *this;
5841 }
5842
5843 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
5844 auto operator<=>( DeviceMemory const & ) const = default;
5845 #else
operator ==(DeviceMemory const & rhs) const5846 bool operator==( DeviceMemory const & rhs ) const VULKAN_HPP_NOEXCEPT
5847 {
5848 return m_deviceMemory == rhs.m_deviceMemory;
5849 }
5850
operator !=(DeviceMemory const & rhs) const5851 bool operator!=(DeviceMemory const & rhs ) const VULKAN_HPP_NOEXCEPT
5852 {
5853 return m_deviceMemory != rhs.m_deviceMemory;
5854 }
5855
operator <(DeviceMemory const & rhs) const5856 bool operator<(DeviceMemory const & rhs ) const VULKAN_HPP_NOEXCEPT
5857 {
5858 return m_deviceMemory < rhs.m_deviceMemory;
5859 }
5860 #endif
5861
operator VkDeviceMemory() const5862 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDeviceMemory() const VULKAN_HPP_NOEXCEPT
5863 {
5864 return m_deviceMemory;
5865 }
5866
operator bool() const5867 explicit operator bool() const VULKAN_HPP_NOEXCEPT
5868 {
5869 return m_deviceMemory != VK_NULL_HANDLE;
5870 }
5871
operator !() const5872 bool operator!() const VULKAN_HPP_NOEXCEPT
5873 {
5874 return m_deviceMemory == VK_NULL_HANDLE;
5875 }
5876
5877 private:
5878 VkDeviceMemory m_deviceMemory = {};
5879 };
5880
5881 template <>
5882 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDeviceMemory>
5883 {
5884 using Type = VULKAN_HPP_NAMESPACE::DeviceMemory;
5885 };
5886
5887
5888 template <>
5889 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDeviceMemory>
5890 {
5891 using Type = VULKAN_HPP_NAMESPACE::DeviceMemory;
5892 };
5893
5894
5895 template <>
5896 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DeviceMemory>
5897 {
5898 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
5899 };
5900
5901 class VideoSessionKHR
5902 {
5903 public:
5904 using CType = VkVideoSessionKHR;
5905 using NativeType = VkVideoSessionKHR;
5906
5907 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionKHR;
5908 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
5909
5910 public:
5911 VULKAN_HPP_CONSTEXPR VideoSessionKHR() = default;
VideoSessionKHR(std::nullptr_t)5912 VULKAN_HPP_CONSTEXPR VideoSessionKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5913 {}
VideoSessionKHR(VkVideoSessionKHR videoSessionKHR)5914 VULKAN_HPP_TYPESAFE_EXPLICIT VideoSessionKHR( VkVideoSessionKHR videoSessionKHR ) VULKAN_HPP_NOEXCEPT
5915 : m_videoSessionKHR( videoSessionKHR )
5916 {}
5917
5918 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkVideoSessionKHR videoSessionKHR)5919 VideoSessionKHR & operator=(VkVideoSessionKHR videoSessionKHR) VULKAN_HPP_NOEXCEPT
5920 {
5921 m_videoSessionKHR = videoSessionKHR;
5922 return *this;
5923 }
5924 #endif
5925
operator =(std::nullptr_t)5926 VideoSessionKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5927 {
5928 m_videoSessionKHR = {};
5929 return *this;
5930 }
5931
5932 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
5933 auto operator<=>( VideoSessionKHR const & ) const = default;
5934 #else
operator ==(VideoSessionKHR const & rhs) const5935 bool operator==( VideoSessionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
5936 {
5937 return m_videoSessionKHR == rhs.m_videoSessionKHR;
5938 }
5939
operator !=(VideoSessionKHR const & rhs) const5940 bool operator!=(VideoSessionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
5941 {
5942 return m_videoSessionKHR != rhs.m_videoSessionKHR;
5943 }
5944
operator <(VideoSessionKHR const & rhs) const5945 bool operator<(VideoSessionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
5946 {
5947 return m_videoSessionKHR < rhs.m_videoSessionKHR;
5948 }
5949 #endif
5950
operator VkVideoSessionKHR() const5951 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkVideoSessionKHR() const VULKAN_HPP_NOEXCEPT
5952 {
5953 return m_videoSessionKHR;
5954 }
5955
operator bool() const5956 explicit operator bool() const VULKAN_HPP_NOEXCEPT
5957 {
5958 return m_videoSessionKHR != VK_NULL_HANDLE;
5959 }
5960
operator !() const5961 bool operator!() const VULKAN_HPP_NOEXCEPT
5962 {
5963 return m_videoSessionKHR == VK_NULL_HANDLE;
5964 }
5965
5966 private:
5967 VkVideoSessionKHR m_videoSessionKHR = {};
5968 };
5969
5970 template <>
5971 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionKHR>
5972 {
5973 using Type = VULKAN_HPP_NAMESPACE::VideoSessionKHR;
5974 };
5975
5976
5977
5978 template <>
5979 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::VideoSessionKHR>
5980 {
5981 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
5982 };
5983
5984 class DeferredOperationKHR
5985 {
5986 public:
5987 using CType = VkDeferredOperationKHR;
5988 using NativeType = VkDeferredOperationKHR;
5989
5990 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDeferredOperationKHR;
5991 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
5992
5993 public:
5994 VULKAN_HPP_CONSTEXPR DeferredOperationKHR() = default;
DeferredOperationKHR(std::nullptr_t)5995 VULKAN_HPP_CONSTEXPR DeferredOperationKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5996 {}
DeferredOperationKHR(VkDeferredOperationKHR deferredOperationKHR)5997 VULKAN_HPP_TYPESAFE_EXPLICIT DeferredOperationKHR( VkDeferredOperationKHR deferredOperationKHR ) VULKAN_HPP_NOEXCEPT
5998 : m_deferredOperationKHR( deferredOperationKHR )
5999 {}
6000
6001 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkDeferredOperationKHR deferredOperationKHR)6002 DeferredOperationKHR & operator=(VkDeferredOperationKHR deferredOperationKHR) VULKAN_HPP_NOEXCEPT
6003 {
6004 m_deferredOperationKHR = deferredOperationKHR;
6005 return *this;
6006 }
6007 #endif
6008
operator =(std::nullptr_t)6009 DeferredOperationKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6010 {
6011 m_deferredOperationKHR = {};
6012 return *this;
6013 }
6014
6015 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
6016 auto operator<=>( DeferredOperationKHR const & ) const = default;
6017 #else
operator ==(DeferredOperationKHR const & rhs) const6018 bool operator==( DeferredOperationKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
6019 {
6020 return m_deferredOperationKHR == rhs.m_deferredOperationKHR;
6021 }
6022
operator !=(DeferredOperationKHR const & rhs) const6023 bool operator!=(DeferredOperationKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
6024 {
6025 return m_deferredOperationKHR != rhs.m_deferredOperationKHR;
6026 }
6027
operator <(DeferredOperationKHR const & rhs) const6028 bool operator<(DeferredOperationKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
6029 {
6030 return m_deferredOperationKHR < rhs.m_deferredOperationKHR;
6031 }
6032 #endif
6033
operator VkDeferredOperationKHR() const6034 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDeferredOperationKHR() const VULKAN_HPP_NOEXCEPT
6035 {
6036 return m_deferredOperationKHR;
6037 }
6038
operator bool() const6039 explicit operator bool() const VULKAN_HPP_NOEXCEPT
6040 {
6041 return m_deferredOperationKHR != VK_NULL_HANDLE;
6042 }
6043
operator !() const6044 bool operator!() const VULKAN_HPP_NOEXCEPT
6045 {
6046 return m_deferredOperationKHR == VK_NULL_HANDLE;
6047 }
6048
6049 private:
6050 VkDeferredOperationKHR m_deferredOperationKHR = {};
6051 };
6052
6053 template <>
6054 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDeferredOperationKHR>
6055 {
6056 using Type = VULKAN_HPP_NAMESPACE::DeferredOperationKHR;
6057 };
6058
6059
6060
6061 template <>
6062 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DeferredOperationKHR>
6063 {
6064 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
6065 };
6066
6067 #if defined( VK_USE_PLATFORM_FUCHSIA )
6068 class BufferCollectionFUCHSIA
6069 {
6070 public:
6071 using CType = VkBufferCollectionFUCHSIA;
6072 using NativeType = VkBufferCollectionFUCHSIA;
6073
6074 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eBufferCollectionFUCHSIA;
6075 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferCollectionFUCHSIA;
6076
6077 public:
6078 VULKAN_HPP_CONSTEXPR BufferCollectionFUCHSIA() = default;
BufferCollectionFUCHSIA(std::nullptr_t)6079 VULKAN_HPP_CONSTEXPR BufferCollectionFUCHSIA( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6080 {}
BufferCollectionFUCHSIA(VkBufferCollectionFUCHSIA bufferCollectionFUCHSIA)6081 VULKAN_HPP_TYPESAFE_EXPLICIT BufferCollectionFUCHSIA( VkBufferCollectionFUCHSIA bufferCollectionFUCHSIA ) VULKAN_HPP_NOEXCEPT
6082 : m_bufferCollectionFUCHSIA( bufferCollectionFUCHSIA )
6083 {}
6084
6085 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkBufferCollectionFUCHSIA bufferCollectionFUCHSIA)6086 BufferCollectionFUCHSIA & operator=(VkBufferCollectionFUCHSIA bufferCollectionFUCHSIA) VULKAN_HPP_NOEXCEPT
6087 {
6088 m_bufferCollectionFUCHSIA = bufferCollectionFUCHSIA;
6089 return *this;
6090 }
6091 #endif
6092
operator =(std::nullptr_t)6093 BufferCollectionFUCHSIA & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6094 {
6095 m_bufferCollectionFUCHSIA = {};
6096 return *this;
6097 }
6098
6099 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
6100 auto operator<=>( BufferCollectionFUCHSIA const & ) const = default;
6101 #else
operator ==(BufferCollectionFUCHSIA const & rhs) const6102 bool operator==( BufferCollectionFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
6103 {
6104 return m_bufferCollectionFUCHSIA == rhs.m_bufferCollectionFUCHSIA;
6105 }
6106
operator !=(BufferCollectionFUCHSIA const & rhs) const6107 bool operator!=(BufferCollectionFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
6108 {
6109 return m_bufferCollectionFUCHSIA != rhs.m_bufferCollectionFUCHSIA;
6110 }
6111
operator <(BufferCollectionFUCHSIA const & rhs) const6112 bool operator<(BufferCollectionFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
6113 {
6114 return m_bufferCollectionFUCHSIA < rhs.m_bufferCollectionFUCHSIA;
6115 }
6116 #endif
6117
operator VkBufferCollectionFUCHSIA() const6118 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBufferCollectionFUCHSIA() const VULKAN_HPP_NOEXCEPT
6119 {
6120 return m_bufferCollectionFUCHSIA;
6121 }
6122
operator bool() const6123 explicit operator bool() const VULKAN_HPP_NOEXCEPT
6124 {
6125 return m_bufferCollectionFUCHSIA != VK_NULL_HANDLE;
6126 }
6127
operator !() const6128 bool operator!() const VULKAN_HPP_NOEXCEPT
6129 {
6130 return m_bufferCollectionFUCHSIA == VK_NULL_HANDLE;
6131 }
6132
6133 private:
6134 VkBufferCollectionFUCHSIA m_bufferCollectionFUCHSIA = {};
6135 };
6136
6137 template <>
6138 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eBufferCollectionFUCHSIA>
6139 {
6140 using Type = VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA;
6141 };
6142
6143
6144 template <>
6145 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferCollectionFUCHSIA>
6146 {
6147 using Type = VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA;
6148 };
6149
6150
6151 template <>
6152 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA>
6153 {
6154 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
6155 };
6156 #endif /*VK_USE_PLATFORM_FUCHSIA*/
6157
6158 class BufferView
6159 {
6160 public:
6161 using CType = VkBufferView;
6162 using NativeType = VkBufferView;
6163
6164 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eBufferView;
6165 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferView;
6166
6167 public:
6168 VULKAN_HPP_CONSTEXPR BufferView() = default;
BufferView(std::nullptr_t)6169 VULKAN_HPP_CONSTEXPR BufferView( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6170 {}
BufferView(VkBufferView bufferView)6171 VULKAN_HPP_TYPESAFE_EXPLICIT BufferView( VkBufferView bufferView ) VULKAN_HPP_NOEXCEPT
6172 : m_bufferView( bufferView )
6173 {}
6174
6175 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkBufferView bufferView)6176 BufferView & operator=(VkBufferView bufferView) VULKAN_HPP_NOEXCEPT
6177 {
6178 m_bufferView = bufferView;
6179 return *this;
6180 }
6181 #endif
6182
operator =(std::nullptr_t)6183 BufferView & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6184 {
6185 m_bufferView = {};
6186 return *this;
6187 }
6188
6189 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
6190 auto operator<=>( BufferView const & ) const = default;
6191 #else
operator ==(BufferView const & rhs) const6192 bool operator==( BufferView const & rhs ) const VULKAN_HPP_NOEXCEPT
6193 {
6194 return m_bufferView == rhs.m_bufferView;
6195 }
6196
operator !=(BufferView const & rhs) const6197 bool operator!=(BufferView const & rhs ) const VULKAN_HPP_NOEXCEPT
6198 {
6199 return m_bufferView != rhs.m_bufferView;
6200 }
6201
operator <(BufferView const & rhs) const6202 bool operator<(BufferView const & rhs ) const VULKAN_HPP_NOEXCEPT
6203 {
6204 return m_bufferView < rhs.m_bufferView;
6205 }
6206 #endif
6207
operator VkBufferView() const6208 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBufferView() const VULKAN_HPP_NOEXCEPT
6209 {
6210 return m_bufferView;
6211 }
6212
operator bool() const6213 explicit operator bool() const VULKAN_HPP_NOEXCEPT
6214 {
6215 return m_bufferView != VK_NULL_HANDLE;
6216 }
6217
operator !() const6218 bool operator!() const VULKAN_HPP_NOEXCEPT
6219 {
6220 return m_bufferView == VK_NULL_HANDLE;
6221 }
6222
6223 private:
6224 VkBufferView m_bufferView = {};
6225 };
6226
6227 template <>
6228 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eBufferView>
6229 {
6230 using Type = VULKAN_HPP_NAMESPACE::BufferView;
6231 };
6232
6233
6234 template <>
6235 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferView>
6236 {
6237 using Type = VULKAN_HPP_NAMESPACE::BufferView;
6238 };
6239
6240
6241 template <>
6242 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::BufferView>
6243 {
6244 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
6245 };
6246
6247 class CommandPool
6248 {
6249 public:
6250 using CType = VkCommandPool;
6251 using NativeType = VkCommandPool;
6252
6253 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCommandPool;
6254 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandPool;
6255
6256 public:
6257 VULKAN_HPP_CONSTEXPR CommandPool() = default;
CommandPool(std::nullptr_t)6258 VULKAN_HPP_CONSTEXPR CommandPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6259 {}
CommandPool(VkCommandPool commandPool)6260 VULKAN_HPP_TYPESAFE_EXPLICIT CommandPool( VkCommandPool commandPool ) VULKAN_HPP_NOEXCEPT
6261 : m_commandPool( commandPool )
6262 {}
6263
6264 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkCommandPool commandPool)6265 CommandPool & operator=(VkCommandPool commandPool) VULKAN_HPP_NOEXCEPT
6266 {
6267 m_commandPool = commandPool;
6268 return *this;
6269 }
6270 #endif
6271
operator =(std::nullptr_t)6272 CommandPool & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6273 {
6274 m_commandPool = {};
6275 return *this;
6276 }
6277
6278 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
6279 auto operator<=>( CommandPool const & ) const = default;
6280 #else
operator ==(CommandPool const & rhs) const6281 bool operator==( CommandPool const & rhs ) const VULKAN_HPP_NOEXCEPT
6282 {
6283 return m_commandPool == rhs.m_commandPool;
6284 }
6285
operator !=(CommandPool const & rhs) const6286 bool operator!=(CommandPool const & rhs ) const VULKAN_HPP_NOEXCEPT
6287 {
6288 return m_commandPool != rhs.m_commandPool;
6289 }
6290
operator <(CommandPool const & rhs) const6291 bool operator<(CommandPool const & rhs ) const VULKAN_HPP_NOEXCEPT
6292 {
6293 return m_commandPool < rhs.m_commandPool;
6294 }
6295 #endif
6296
operator VkCommandPool() const6297 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCommandPool() const VULKAN_HPP_NOEXCEPT
6298 {
6299 return m_commandPool;
6300 }
6301
operator bool() const6302 explicit operator bool() const VULKAN_HPP_NOEXCEPT
6303 {
6304 return m_commandPool != VK_NULL_HANDLE;
6305 }
6306
operator !() const6307 bool operator!() const VULKAN_HPP_NOEXCEPT
6308 {
6309 return m_commandPool == VK_NULL_HANDLE;
6310 }
6311
6312 private:
6313 VkCommandPool m_commandPool = {};
6314 };
6315
6316 template <>
6317 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCommandPool>
6318 {
6319 using Type = VULKAN_HPP_NAMESPACE::CommandPool;
6320 };
6321
6322
6323 template <>
6324 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandPool>
6325 {
6326 using Type = VULKAN_HPP_NAMESPACE::CommandPool;
6327 };
6328
6329
6330 template <>
6331 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CommandPool>
6332 {
6333 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
6334 };
6335
6336 class PipelineCache
6337 {
6338 public:
6339 using CType = VkPipelineCache;
6340 using NativeType = VkPipelineCache;
6341
6342 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePipelineCache;
6343 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineCache;
6344
6345 public:
6346 VULKAN_HPP_CONSTEXPR PipelineCache() = default;
PipelineCache(std::nullptr_t)6347 VULKAN_HPP_CONSTEXPR PipelineCache( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6348 {}
PipelineCache(VkPipelineCache pipelineCache)6349 VULKAN_HPP_TYPESAFE_EXPLICIT PipelineCache( VkPipelineCache pipelineCache ) VULKAN_HPP_NOEXCEPT
6350 : m_pipelineCache( pipelineCache )
6351 {}
6352
6353 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkPipelineCache pipelineCache)6354 PipelineCache & operator=(VkPipelineCache pipelineCache) VULKAN_HPP_NOEXCEPT
6355 {
6356 m_pipelineCache = pipelineCache;
6357 return *this;
6358 }
6359 #endif
6360
operator =(std::nullptr_t)6361 PipelineCache & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6362 {
6363 m_pipelineCache = {};
6364 return *this;
6365 }
6366
6367 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
6368 auto operator<=>( PipelineCache const & ) const = default;
6369 #else
operator ==(PipelineCache const & rhs) const6370 bool operator==( PipelineCache const & rhs ) const VULKAN_HPP_NOEXCEPT
6371 {
6372 return m_pipelineCache == rhs.m_pipelineCache;
6373 }
6374
operator !=(PipelineCache const & rhs) const6375 bool operator!=(PipelineCache const & rhs ) const VULKAN_HPP_NOEXCEPT
6376 {
6377 return m_pipelineCache != rhs.m_pipelineCache;
6378 }
6379
operator <(PipelineCache const & rhs) const6380 bool operator<(PipelineCache const & rhs ) const VULKAN_HPP_NOEXCEPT
6381 {
6382 return m_pipelineCache < rhs.m_pipelineCache;
6383 }
6384 #endif
6385
operator VkPipelineCache() const6386 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineCache() const VULKAN_HPP_NOEXCEPT
6387 {
6388 return m_pipelineCache;
6389 }
6390
operator bool() const6391 explicit operator bool() const VULKAN_HPP_NOEXCEPT
6392 {
6393 return m_pipelineCache != VK_NULL_HANDLE;
6394 }
6395
operator !() const6396 bool operator!() const VULKAN_HPP_NOEXCEPT
6397 {
6398 return m_pipelineCache == VK_NULL_HANDLE;
6399 }
6400
6401 private:
6402 VkPipelineCache m_pipelineCache = {};
6403 };
6404
6405 template <>
6406 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePipelineCache>
6407 {
6408 using Type = VULKAN_HPP_NAMESPACE::PipelineCache;
6409 };
6410
6411
6412 template <>
6413 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineCache>
6414 {
6415 using Type = VULKAN_HPP_NAMESPACE::PipelineCache;
6416 };
6417
6418
6419 template <>
6420 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PipelineCache>
6421 {
6422 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
6423 };
6424
6425 class CuFunctionNVX
6426 {
6427 public:
6428 using CType = VkCuFunctionNVX;
6429 using NativeType = VkCuFunctionNVX;
6430
6431 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCuFunctionNVX;
6432 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCuFunctionNVX;
6433
6434 public:
6435 VULKAN_HPP_CONSTEXPR CuFunctionNVX() = default;
CuFunctionNVX(std::nullptr_t)6436 VULKAN_HPP_CONSTEXPR CuFunctionNVX( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6437 {}
CuFunctionNVX(VkCuFunctionNVX cuFunctionNVX)6438 VULKAN_HPP_TYPESAFE_EXPLICIT CuFunctionNVX( VkCuFunctionNVX cuFunctionNVX ) VULKAN_HPP_NOEXCEPT
6439 : m_cuFunctionNVX( cuFunctionNVX )
6440 {}
6441
6442 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkCuFunctionNVX cuFunctionNVX)6443 CuFunctionNVX & operator=(VkCuFunctionNVX cuFunctionNVX) VULKAN_HPP_NOEXCEPT
6444 {
6445 m_cuFunctionNVX = cuFunctionNVX;
6446 return *this;
6447 }
6448 #endif
6449
operator =(std::nullptr_t)6450 CuFunctionNVX & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6451 {
6452 m_cuFunctionNVX = {};
6453 return *this;
6454 }
6455
6456 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
6457 auto operator<=>( CuFunctionNVX const & ) const = default;
6458 #else
operator ==(CuFunctionNVX const & rhs) const6459 bool operator==( CuFunctionNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
6460 {
6461 return m_cuFunctionNVX == rhs.m_cuFunctionNVX;
6462 }
6463
operator !=(CuFunctionNVX const & rhs) const6464 bool operator!=(CuFunctionNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
6465 {
6466 return m_cuFunctionNVX != rhs.m_cuFunctionNVX;
6467 }
6468
operator <(CuFunctionNVX const & rhs) const6469 bool operator<(CuFunctionNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
6470 {
6471 return m_cuFunctionNVX < rhs.m_cuFunctionNVX;
6472 }
6473 #endif
6474
operator VkCuFunctionNVX() const6475 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCuFunctionNVX() const VULKAN_HPP_NOEXCEPT
6476 {
6477 return m_cuFunctionNVX;
6478 }
6479
operator bool() const6480 explicit operator bool() const VULKAN_HPP_NOEXCEPT
6481 {
6482 return m_cuFunctionNVX != VK_NULL_HANDLE;
6483 }
6484
operator !() const6485 bool operator!() const VULKAN_HPP_NOEXCEPT
6486 {
6487 return m_cuFunctionNVX == VK_NULL_HANDLE;
6488 }
6489
6490 private:
6491 VkCuFunctionNVX m_cuFunctionNVX = {};
6492 };
6493
6494 template <>
6495 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCuFunctionNVX>
6496 {
6497 using Type = VULKAN_HPP_NAMESPACE::CuFunctionNVX;
6498 };
6499
6500
6501 template <>
6502 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCuFunctionNVX>
6503 {
6504 using Type = VULKAN_HPP_NAMESPACE::CuFunctionNVX;
6505 };
6506
6507
6508 template <>
6509 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CuFunctionNVX>
6510 {
6511 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
6512 };
6513
6514 class CuModuleNVX
6515 {
6516 public:
6517 using CType = VkCuModuleNVX;
6518 using NativeType = VkCuModuleNVX;
6519
6520 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCuModuleNVX;
6521 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCuModuleNVX;
6522
6523 public:
6524 VULKAN_HPP_CONSTEXPR CuModuleNVX() = default;
CuModuleNVX(std::nullptr_t)6525 VULKAN_HPP_CONSTEXPR CuModuleNVX( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6526 {}
CuModuleNVX(VkCuModuleNVX cuModuleNVX)6527 VULKAN_HPP_TYPESAFE_EXPLICIT CuModuleNVX( VkCuModuleNVX cuModuleNVX ) VULKAN_HPP_NOEXCEPT
6528 : m_cuModuleNVX( cuModuleNVX )
6529 {}
6530
6531 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkCuModuleNVX cuModuleNVX)6532 CuModuleNVX & operator=(VkCuModuleNVX cuModuleNVX) VULKAN_HPP_NOEXCEPT
6533 {
6534 m_cuModuleNVX = cuModuleNVX;
6535 return *this;
6536 }
6537 #endif
6538
operator =(std::nullptr_t)6539 CuModuleNVX & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6540 {
6541 m_cuModuleNVX = {};
6542 return *this;
6543 }
6544
6545 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
6546 auto operator<=>( CuModuleNVX const & ) const = default;
6547 #else
operator ==(CuModuleNVX const & rhs) const6548 bool operator==( CuModuleNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
6549 {
6550 return m_cuModuleNVX == rhs.m_cuModuleNVX;
6551 }
6552
operator !=(CuModuleNVX const & rhs) const6553 bool operator!=(CuModuleNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
6554 {
6555 return m_cuModuleNVX != rhs.m_cuModuleNVX;
6556 }
6557
operator <(CuModuleNVX const & rhs) const6558 bool operator<(CuModuleNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
6559 {
6560 return m_cuModuleNVX < rhs.m_cuModuleNVX;
6561 }
6562 #endif
6563
operator VkCuModuleNVX() const6564 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCuModuleNVX() const VULKAN_HPP_NOEXCEPT
6565 {
6566 return m_cuModuleNVX;
6567 }
6568
operator bool() const6569 explicit operator bool() const VULKAN_HPP_NOEXCEPT
6570 {
6571 return m_cuModuleNVX != VK_NULL_HANDLE;
6572 }
6573
operator !() const6574 bool operator!() const VULKAN_HPP_NOEXCEPT
6575 {
6576 return m_cuModuleNVX == VK_NULL_HANDLE;
6577 }
6578
6579 private:
6580 VkCuModuleNVX m_cuModuleNVX = {};
6581 };
6582
6583 template <>
6584 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCuModuleNVX>
6585 {
6586 using Type = VULKAN_HPP_NAMESPACE::CuModuleNVX;
6587 };
6588
6589
6590 template <>
6591 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCuModuleNVX>
6592 {
6593 using Type = VULKAN_HPP_NAMESPACE::CuModuleNVX;
6594 };
6595
6596
6597 template <>
6598 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CuModuleNVX>
6599 {
6600 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
6601 };
6602
6603 class DescriptorPool
6604 {
6605 public:
6606 using CType = VkDescriptorPool;
6607 using NativeType = VkDescriptorPool;
6608
6609 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorPool;
6610 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorPool;
6611
6612 public:
6613 VULKAN_HPP_CONSTEXPR DescriptorPool() = default;
DescriptorPool(std::nullptr_t)6614 VULKAN_HPP_CONSTEXPR DescriptorPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6615 {}
DescriptorPool(VkDescriptorPool descriptorPool)6616 VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorPool( VkDescriptorPool descriptorPool ) VULKAN_HPP_NOEXCEPT
6617 : m_descriptorPool( descriptorPool )
6618 {}
6619
6620 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkDescriptorPool descriptorPool)6621 DescriptorPool & operator=(VkDescriptorPool descriptorPool) VULKAN_HPP_NOEXCEPT
6622 {
6623 m_descriptorPool = descriptorPool;
6624 return *this;
6625 }
6626 #endif
6627
operator =(std::nullptr_t)6628 DescriptorPool & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6629 {
6630 m_descriptorPool = {};
6631 return *this;
6632 }
6633
6634 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
6635 auto operator<=>( DescriptorPool const & ) const = default;
6636 #else
operator ==(DescriptorPool const & rhs) const6637 bool operator==( DescriptorPool const & rhs ) const VULKAN_HPP_NOEXCEPT
6638 {
6639 return m_descriptorPool == rhs.m_descriptorPool;
6640 }
6641
operator !=(DescriptorPool const & rhs) const6642 bool operator!=(DescriptorPool const & rhs ) const VULKAN_HPP_NOEXCEPT
6643 {
6644 return m_descriptorPool != rhs.m_descriptorPool;
6645 }
6646
operator <(DescriptorPool const & rhs) const6647 bool operator<(DescriptorPool const & rhs ) const VULKAN_HPP_NOEXCEPT
6648 {
6649 return m_descriptorPool < rhs.m_descriptorPool;
6650 }
6651 #endif
6652
operator VkDescriptorPool() const6653 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorPool() const VULKAN_HPP_NOEXCEPT
6654 {
6655 return m_descriptorPool;
6656 }
6657
operator bool() const6658 explicit operator bool() const VULKAN_HPP_NOEXCEPT
6659 {
6660 return m_descriptorPool != VK_NULL_HANDLE;
6661 }
6662
operator !() const6663 bool operator!() const VULKAN_HPP_NOEXCEPT
6664 {
6665 return m_descriptorPool == VK_NULL_HANDLE;
6666 }
6667
6668 private:
6669 VkDescriptorPool m_descriptorPool = {};
6670 };
6671
6672 template <>
6673 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorPool>
6674 {
6675 using Type = VULKAN_HPP_NAMESPACE::DescriptorPool;
6676 };
6677
6678
6679 template <>
6680 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorPool>
6681 {
6682 using Type = VULKAN_HPP_NAMESPACE::DescriptorPool;
6683 };
6684
6685
6686 template <>
6687 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DescriptorPool>
6688 {
6689 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
6690 };
6691
6692 class DescriptorSetLayout
6693 {
6694 public:
6695 using CType = VkDescriptorSetLayout;
6696 using NativeType = VkDescriptorSetLayout;
6697
6698 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSetLayout;
6699 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSetLayout;
6700
6701 public:
6702 VULKAN_HPP_CONSTEXPR DescriptorSetLayout() = default;
DescriptorSetLayout(std::nullptr_t)6703 VULKAN_HPP_CONSTEXPR DescriptorSetLayout( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6704 {}
DescriptorSetLayout(VkDescriptorSetLayout descriptorSetLayout)6705 VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSetLayout( VkDescriptorSetLayout descriptorSetLayout ) VULKAN_HPP_NOEXCEPT
6706 : m_descriptorSetLayout( descriptorSetLayout )
6707 {}
6708
6709 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkDescriptorSetLayout descriptorSetLayout)6710 DescriptorSetLayout & operator=(VkDescriptorSetLayout descriptorSetLayout) VULKAN_HPP_NOEXCEPT
6711 {
6712 m_descriptorSetLayout = descriptorSetLayout;
6713 return *this;
6714 }
6715 #endif
6716
operator =(std::nullptr_t)6717 DescriptorSetLayout & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6718 {
6719 m_descriptorSetLayout = {};
6720 return *this;
6721 }
6722
6723 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
6724 auto operator<=>( DescriptorSetLayout const & ) const = default;
6725 #else
operator ==(DescriptorSetLayout const & rhs) const6726 bool operator==( DescriptorSetLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
6727 {
6728 return m_descriptorSetLayout == rhs.m_descriptorSetLayout;
6729 }
6730
operator !=(DescriptorSetLayout const & rhs) const6731 bool operator!=(DescriptorSetLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
6732 {
6733 return m_descriptorSetLayout != rhs.m_descriptorSetLayout;
6734 }
6735
operator <(DescriptorSetLayout const & rhs) const6736 bool operator<(DescriptorSetLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
6737 {
6738 return m_descriptorSetLayout < rhs.m_descriptorSetLayout;
6739 }
6740 #endif
6741
operator VkDescriptorSetLayout() const6742 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorSetLayout() const VULKAN_HPP_NOEXCEPT
6743 {
6744 return m_descriptorSetLayout;
6745 }
6746
operator bool() const6747 explicit operator bool() const VULKAN_HPP_NOEXCEPT
6748 {
6749 return m_descriptorSetLayout != VK_NULL_HANDLE;
6750 }
6751
operator !() const6752 bool operator!() const VULKAN_HPP_NOEXCEPT
6753 {
6754 return m_descriptorSetLayout == VK_NULL_HANDLE;
6755 }
6756
6757 private:
6758 VkDescriptorSetLayout m_descriptorSetLayout = {};
6759 };
6760
6761 template <>
6762 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSetLayout>
6763 {
6764 using Type = VULKAN_HPP_NAMESPACE::DescriptorSetLayout;
6765 };
6766
6767
6768 template <>
6769 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSetLayout>
6770 {
6771 using Type = VULKAN_HPP_NAMESPACE::DescriptorSetLayout;
6772 };
6773
6774
6775 template <>
6776 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DescriptorSetLayout>
6777 {
6778 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
6779 };
6780
6781 class Framebuffer
6782 {
6783 public:
6784 using CType = VkFramebuffer;
6785 using NativeType = VkFramebuffer;
6786
6787 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eFramebuffer;
6788 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFramebuffer;
6789
6790 public:
6791 VULKAN_HPP_CONSTEXPR Framebuffer() = default;
Framebuffer(std::nullptr_t)6792 VULKAN_HPP_CONSTEXPR Framebuffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6793 {}
Framebuffer(VkFramebuffer framebuffer)6794 VULKAN_HPP_TYPESAFE_EXPLICIT Framebuffer( VkFramebuffer framebuffer ) VULKAN_HPP_NOEXCEPT
6795 : m_framebuffer( framebuffer )
6796 {}
6797
6798 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkFramebuffer framebuffer)6799 Framebuffer & operator=(VkFramebuffer framebuffer) VULKAN_HPP_NOEXCEPT
6800 {
6801 m_framebuffer = framebuffer;
6802 return *this;
6803 }
6804 #endif
6805
operator =(std::nullptr_t)6806 Framebuffer & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6807 {
6808 m_framebuffer = {};
6809 return *this;
6810 }
6811
6812 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
6813 auto operator<=>( Framebuffer const & ) const = default;
6814 #else
operator ==(Framebuffer const & rhs) const6815 bool operator==( Framebuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
6816 {
6817 return m_framebuffer == rhs.m_framebuffer;
6818 }
6819
operator !=(Framebuffer const & rhs) const6820 bool operator!=(Framebuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
6821 {
6822 return m_framebuffer != rhs.m_framebuffer;
6823 }
6824
operator <(Framebuffer const & rhs) const6825 bool operator<(Framebuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
6826 {
6827 return m_framebuffer < rhs.m_framebuffer;
6828 }
6829 #endif
6830
operator VkFramebuffer() const6831 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkFramebuffer() const VULKAN_HPP_NOEXCEPT
6832 {
6833 return m_framebuffer;
6834 }
6835
operator bool() const6836 explicit operator bool() const VULKAN_HPP_NOEXCEPT
6837 {
6838 return m_framebuffer != VK_NULL_HANDLE;
6839 }
6840
operator !() const6841 bool operator!() const VULKAN_HPP_NOEXCEPT
6842 {
6843 return m_framebuffer == VK_NULL_HANDLE;
6844 }
6845
6846 private:
6847 VkFramebuffer m_framebuffer = {};
6848 };
6849
6850 template <>
6851 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eFramebuffer>
6852 {
6853 using Type = VULKAN_HPP_NAMESPACE::Framebuffer;
6854 };
6855
6856
6857 template <>
6858 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFramebuffer>
6859 {
6860 using Type = VULKAN_HPP_NAMESPACE::Framebuffer;
6861 };
6862
6863
6864 template <>
6865 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Framebuffer>
6866 {
6867 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
6868 };
6869
6870 class IndirectCommandsLayoutNV
6871 {
6872 public:
6873 using CType = VkIndirectCommandsLayoutNV;
6874 using NativeType = VkIndirectCommandsLayoutNV;
6875
6876 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eIndirectCommandsLayoutNV;
6877 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
6878
6879 public:
6880 VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutNV() = default;
IndirectCommandsLayoutNV(std::nullptr_t)6881 VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6882 {}
IndirectCommandsLayoutNV(VkIndirectCommandsLayoutNV indirectCommandsLayoutNV)6883 VULKAN_HPP_TYPESAFE_EXPLICIT IndirectCommandsLayoutNV( VkIndirectCommandsLayoutNV indirectCommandsLayoutNV ) VULKAN_HPP_NOEXCEPT
6884 : m_indirectCommandsLayoutNV( indirectCommandsLayoutNV )
6885 {}
6886
6887 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkIndirectCommandsLayoutNV indirectCommandsLayoutNV)6888 IndirectCommandsLayoutNV & operator=(VkIndirectCommandsLayoutNV indirectCommandsLayoutNV) VULKAN_HPP_NOEXCEPT
6889 {
6890 m_indirectCommandsLayoutNV = indirectCommandsLayoutNV;
6891 return *this;
6892 }
6893 #endif
6894
operator =(std::nullptr_t)6895 IndirectCommandsLayoutNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6896 {
6897 m_indirectCommandsLayoutNV = {};
6898 return *this;
6899 }
6900
6901 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
6902 auto operator<=>( IndirectCommandsLayoutNV const & ) const = default;
6903 #else
operator ==(IndirectCommandsLayoutNV const & rhs) const6904 bool operator==( IndirectCommandsLayoutNV const & rhs ) const VULKAN_HPP_NOEXCEPT
6905 {
6906 return m_indirectCommandsLayoutNV == rhs.m_indirectCommandsLayoutNV;
6907 }
6908
operator !=(IndirectCommandsLayoutNV const & rhs) const6909 bool operator!=(IndirectCommandsLayoutNV const & rhs ) const VULKAN_HPP_NOEXCEPT
6910 {
6911 return m_indirectCommandsLayoutNV != rhs.m_indirectCommandsLayoutNV;
6912 }
6913
operator <(IndirectCommandsLayoutNV const & rhs) const6914 bool operator<(IndirectCommandsLayoutNV const & rhs ) const VULKAN_HPP_NOEXCEPT
6915 {
6916 return m_indirectCommandsLayoutNV < rhs.m_indirectCommandsLayoutNV;
6917 }
6918 #endif
6919
operator VkIndirectCommandsLayoutNV() const6920 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkIndirectCommandsLayoutNV() const VULKAN_HPP_NOEXCEPT
6921 {
6922 return m_indirectCommandsLayoutNV;
6923 }
6924
operator bool() const6925 explicit operator bool() const VULKAN_HPP_NOEXCEPT
6926 {
6927 return m_indirectCommandsLayoutNV != VK_NULL_HANDLE;
6928 }
6929
operator !() const6930 bool operator!() const VULKAN_HPP_NOEXCEPT
6931 {
6932 return m_indirectCommandsLayoutNV == VK_NULL_HANDLE;
6933 }
6934
6935 private:
6936 VkIndirectCommandsLayoutNV m_indirectCommandsLayoutNV = {};
6937 };
6938
6939 template <>
6940 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eIndirectCommandsLayoutNV>
6941 {
6942 using Type = VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV;
6943 };
6944
6945
6946
6947 template <>
6948 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV>
6949 {
6950 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
6951 };
6952
6953 class PrivateDataSlot
6954 {
6955 public:
6956 using CType = VkPrivateDataSlot;
6957 using NativeType = VkPrivateDataSlot;
6958
6959 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePrivateDataSlot;
6960 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
6961
6962 public:
6963 VULKAN_HPP_CONSTEXPR PrivateDataSlot() = default;
PrivateDataSlot(std::nullptr_t)6964 VULKAN_HPP_CONSTEXPR PrivateDataSlot( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6965 {}
PrivateDataSlot(VkPrivateDataSlot privateDataSlot)6966 VULKAN_HPP_TYPESAFE_EXPLICIT PrivateDataSlot( VkPrivateDataSlot privateDataSlot ) VULKAN_HPP_NOEXCEPT
6967 : m_privateDataSlot( privateDataSlot )
6968 {}
6969
6970 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkPrivateDataSlot privateDataSlot)6971 PrivateDataSlot & operator=(VkPrivateDataSlot privateDataSlot) VULKAN_HPP_NOEXCEPT
6972 {
6973 m_privateDataSlot = privateDataSlot;
6974 return *this;
6975 }
6976 #endif
6977
operator =(std::nullptr_t)6978 PrivateDataSlot & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6979 {
6980 m_privateDataSlot = {};
6981 return *this;
6982 }
6983
6984 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
6985 auto operator<=>( PrivateDataSlot const & ) const = default;
6986 #else
operator ==(PrivateDataSlot const & rhs) const6987 bool operator==( PrivateDataSlot const & rhs ) const VULKAN_HPP_NOEXCEPT
6988 {
6989 return m_privateDataSlot == rhs.m_privateDataSlot;
6990 }
6991
operator !=(PrivateDataSlot const & rhs) const6992 bool operator!=(PrivateDataSlot const & rhs ) const VULKAN_HPP_NOEXCEPT
6993 {
6994 return m_privateDataSlot != rhs.m_privateDataSlot;
6995 }
6996
operator <(PrivateDataSlot const & rhs) const6997 bool operator<(PrivateDataSlot const & rhs ) const VULKAN_HPP_NOEXCEPT
6998 {
6999 return m_privateDataSlot < rhs.m_privateDataSlot;
7000 }
7001 #endif
7002
operator VkPrivateDataSlot() const7003 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPrivateDataSlot() const VULKAN_HPP_NOEXCEPT
7004 {
7005 return m_privateDataSlot;
7006 }
7007
operator bool() const7008 explicit operator bool() const VULKAN_HPP_NOEXCEPT
7009 {
7010 return m_privateDataSlot != VK_NULL_HANDLE;
7011 }
7012
operator !() const7013 bool operator!() const VULKAN_HPP_NOEXCEPT
7014 {
7015 return m_privateDataSlot == VK_NULL_HANDLE;
7016 }
7017
7018 private:
7019 VkPrivateDataSlot m_privateDataSlot = {};
7020 };
7021
7022 template <>
7023 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePrivateDataSlot>
7024 {
7025 using Type = VULKAN_HPP_NAMESPACE::PrivateDataSlot;
7026 };
7027
7028
7029
7030 template <>
7031 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PrivateDataSlot>
7032 {
7033 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
7034 };
7035 using PrivateDataSlotEXT = PrivateDataSlot;
7036
7037 class RenderPass
7038 {
7039 public:
7040 using CType = VkRenderPass;
7041 using NativeType = VkRenderPass;
7042
7043 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eRenderPass;
7044 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eRenderPass;
7045
7046 public:
7047 VULKAN_HPP_CONSTEXPR RenderPass() = default;
RenderPass(std::nullptr_t)7048 VULKAN_HPP_CONSTEXPR RenderPass( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
7049 {}
RenderPass(VkRenderPass renderPass)7050 VULKAN_HPP_TYPESAFE_EXPLICIT RenderPass( VkRenderPass renderPass ) VULKAN_HPP_NOEXCEPT
7051 : m_renderPass( renderPass )
7052 {}
7053
7054 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkRenderPass renderPass)7055 RenderPass & operator=(VkRenderPass renderPass) VULKAN_HPP_NOEXCEPT
7056 {
7057 m_renderPass = renderPass;
7058 return *this;
7059 }
7060 #endif
7061
operator =(std::nullptr_t)7062 RenderPass & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
7063 {
7064 m_renderPass = {};
7065 return *this;
7066 }
7067
7068 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
7069 auto operator<=>( RenderPass const & ) const = default;
7070 #else
operator ==(RenderPass const & rhs) const7071 bool operator==( RenderPass const & rhs ) const VULKAN_HPP_NOEXCEPT
7072 {
7073 return m_renderPass == rhs.m_renderPass;
7074 }
7075
operator !=(RenderPass const & rhs) const7076 bool operator!=(RenderPass const & rhs ) const VULKAN_HPP_NOEXCEPT
7077 {
7078 return m_renderPass != rhs.m_renderPass;
7079 }
7080
operator <(RenderPass const & rhs) const7081 bool operator<(RenderPass const & rhs ) const VULKAN_HPP_NOEXCEPT
7082 {
7083 return m_renderPass < rhs.m_renderPass;
7084 }
7085 #endif
7086
operator VkRenderPass() const7087 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkRenderPass() const VULKAN_HPP_NOEXCEPT
7088 {
7089 return m_renderPass;
7090 }
7091
operator bool() const7092 explicit operator bool() const VULKAN_HPP_NOEXCEPT
7093 {
7094 return m_renderPass != VK_NULL_HANDLE;
7095 }
7096
operator !() const7097 bool operator!() const VULKAN_HPP_NOEXCEPT
7098 {
7099 return m_renderPass == VK_NULL_HANDLE;
7100 }
7101
7102 private:
7103 VkRenderPass m_renderPass = {};
7104 };
7105
7106 template <>
7107 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eRenderPass>
7108 {
7109 using Type = VULKAN_HPP_NAMESPACE::RenderPass;
7110 };
7111
7112
7113 template <>
7114 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eRenderPass>
7115 {
7116 using Type = VULKAN_HPP_NAMESPACE::RenderPass;
7117 };
7118
7119
7120 template <>
7121 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::RenderPass>
7122 {
7123 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
7124 };
7125
7126 class Sampler
7127 {
7128 public:
7129 using CType = VkSampler;
7130 using NativeType = VkSampler;
7131
7132 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSampler;
7133 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSampler;
7134
7135 public:
7136 VULKAN_HPP_CONSTEXPR Sampler() = default;
Sampler(std::nullptr_t)7137 VULKAN_HPP_CONSTEXPR Sampler( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
7138 {}
Sampler(VkSampler sampler)7139 VULKAN_HPP_TYPESAFE_EXPLICIT Sampler( VkSampler sampler ) VULKAN_HPP_NOEXCEPT
7140 : m_sampler( sampler )
7141 {}
7142
7143 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkSampler sampler)7144 Sampler & operator=(VkSampler sampler) VULKAN_HPP_NOEXCEPT
7145 {
7146 m_sampler = sampler;
7147 return *this;
7148 }
7149 #endif
7150
operator =(std::nullptr_t)7151 Sampler & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
7152 {
7153 m_sampler = {};
7154 return *this;
7155 }
7156
7157 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
7158 auto operator<=>( Sampler const & ) const = default;
7159 #else
operator ==(Sampler const & rhs) const7160 bool operator==( Sampler const & rhs ) const VULKAN_HPP_NOEXCEPT
7161 {
7162 return m_sampler == rhs.m_sampler;
7163 }
7164
operator !=(Sampler const & rhs) const7165 bool operator!=(Sampler const & rhs ) const VULKAN_HPP_NOEXCEPT
7166 {
7167 return m_sampler != rhs.m_sampler;
7168 }
7169
operator <(Sampler const & rhs) const7170 bool operator<(Sampler const & rhs ) const VULKAN_HPP_NOEXCEPT
7171 {
7172 return m_sampler < rhs.m_sampler;
7173 }
7174 #endif
7175
operator VkSampler() const7176 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSampler() const VULKAN_HPP_NOEXCEPT
7177 {
7178 return m_sampler;
7179 }
7180
operator bool() const7181 explicit operator bool() const VULKAN_HPP_NOEXCEPT
7182 {
7183 return m_sampler != VK_NULL_HANDLE;
7184 }
7185
operator !() const7186 bool operator!() const VULKAN_HPP_NOEXCEPT
7187 {
7188 return m_sampler == VK_NULL_HANDLE;
7189 }
7190
7191 private:
7192 VkSampler m_sampler = {};
7193 };
7194
7195 template <>
7196 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSampler>
7197 {
7198 using Type = VULKAN_HPP_NAMESPACE::Sampler;
7199 };
7200
7201
7202 template <>
7203 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSampler>
7204 {
7205 using Type = VULKAN_HPP_NAMESPACE::Sampler;
7206 };
7207
7208
7209 template <>
7210 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Sampler>
7211 {
7212 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
7213 };
7214
7215 class SamplerYcbcrConversion
7216 {
7217 public:
7218 using CType = VkSamplerYcbcrConversion;
7219 using NativeType = VkSamplerYcbcrConversion;
7220
7221 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSamplerYcbcrConversion;
7222 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSamplerYcbcrConversion;
7223
7224 public:
7225 VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion() = default;
SamplerYcbcrConversion(std::nullptr_t)7226 VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
7227 {}
SamplerYcbcrConversion(VkSamplerYcbcrConversion samplerYcbcrConversion)7228 VULKAN_HPP_TYPESAFE_EXPLICIT SamplerYcbcrConversion( VkSamplerYcbcrConversion samplerYcbcrConversion ) VULKAN_HPP_NOEXCEPT
7229 : m_samplerYcbcrConversion( samplerYcbcrConversion )
7230 {}
7231
7232 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkSamplerYcbcrConversion samplerYcbcrConversion)7233 SamplerYcbcrConversion & operator=(VkSamplerYcbcrConversion samplerYcbcrConversion) VULKAN_HPP_NOEXCEPT
7234 {
7235 m_samplerYcbcrConversion = samplerYcbcrConversion;
7236 return *this;
7237 }
7238 #endif
7239
operator =(std::nullptr_t)7240 SamplerYcbcrConversion & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
7241 {
7242 m_samplerYcbcrConversion = {};
7243 return *this;
7244 }
7245
7246 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
7247 auto operator<=>( SamplerYcbcrConversion const & ) const = default;
7248 #else
operator ==(SamplerYcbcrConversion const & rhs) const7249 bool operator==( SamplerYcbcrConversion const & rhs ) const VULKAN_HPP_NOEXCEPT
7250 {
7251 return m_samplerYcbcrConversion == rhs.m_samplerYcbcrConversion;
7252 }
7253
operator !=(SamplerYcbcrConversion const & rhs) const7254 bool operator!=(SamplerYcbcrConversion const & rhs ) const VULKAN_HPP_NOEXCEPT
7255 {
7256 return m_samplerYcbcrConversion != rhs.m_samplerYcbcrConversion;
7257 }
7258
operator <(SamplerYcbcrConversion const & rhs) const7259 bool operator<(SamplerYcbcrConversion const & rhs ) const VULKAN_HPP_NOEXCEPT
7260 {
7261 return m_samplerYcbcrConversion < rhs.m_samplerYcbcrConversion;
7262 }
7263 #endif
7264
operator VkSamplerYcbcrConversion() const7265 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSamplerYcbcrConversion() const VULKAN_HPP_NOEXCEPT
7266 {
7267 return m_samplerYcbcrConversion;
7268 }
7269
operator bool() const7270 explicit operator bool() const VULKAN_HPP_NOEXCEPT
7271 {
7272 return m_samplerYcbcrConversion != VK_NULL_HANDLE;
7273 }
7274
operator !() const7275 bool operator!() const VULKAN_HPP_NOEXCEPT
7276 {
7277 return m_samplerYcbcrConversion == VK_NULL_HANDLE;
7278 }
7279
7280 private:
7281 VkSamplerYcbcrConversion m_samplerYcbcrConversion = {};
7282 };
7283
7284 template <>
7285 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSamplerYcbcrConversion>
7286 {
7287 using Type = VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion;
7288 };
7289
7290
7291 template <>
7292 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSamplerYcbcrConversion>
7293 {
7294 using Type = VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion;
7295 };
7296
7297
7298 template <>
7299 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>
7300 {
7301 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
7302 };
7303 using SamplerYcbcrConversionKHR = SamplerYcbcrConversion;
7304
7305 class ShaderModule
7306 {
7307 public:
7308 using CType = VkShaderModule;
7309 using NativeType = VkShaderModule;
7310
7311 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eShaderModule;
7312 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eShaderModule;
7313
7314 public:
7315 VULKAN_HPP_CONSTEXPR ShaderModule() = default;
ShaderModule(std::nullptr_t)7316 VULKAN_HPP_CONSTEXPR ShaderModule( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
7317 {}
ShaderModule(VkShaderModule shaderModule)7318 VULKAN_HPP_TYPESAFE_EXPLICIT ShaderModule( VkShaderModule shaderModule ) VULKAN_HPP_NOEXCEPT
7319 : m_shaderModule( shaderModule )
7320 {}
7321
7322 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkShaderModule shaderModule)7323 ShaderModule & operator=(VkShaderModule shaderModule) VULKAN_HPP_NOEXCEPT
7324 {
7325 m_shaderModule = shaderModule;
7326 return *this;
7327 }
7328 #endif
7329
operator =(std::nullptr_t)7330 ShaderModule & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
7331 {
7332 m_shaderModule = {};
7333 return *this;
7334 }
7335
7336 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
7337 auto operator<=>( ShaderModule const & ) const = default;
7338 #else
operator ==(ShaderModule const & rhs) const7339 bool operator==( ShaderModule const & rhs ) const VULKAN_HPP_NOEXCEPT
7340 {
7341 return m_shaderModule == rhs.m_shaderModule;
7342 }
7343
operator !=(ShaderModule const & rhs) const7344 bool operator!=(ShaderModule const & rhs ) const VULKAN_HPP_NOEXCEPT
7345 {
7346 return m_shaderModule != rhs.m_shaderModule;
7347 }
7348
operator <(ShaderModule const & rhs) const7349 bool operator<(ShaderModule const & rhs ) const VULKAN_HPP_NOEXCEPT
7350 {
7351 return m_shaderModule < rhs.m_shaderModule;
7352 }
7353 #endif
7354
operator VkShaderModule() const7355 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkShaderModule() const VULKAN_HPP_NOEXCEPT
7356 {
7357 return m_shaderModule;
7358 }
7359
operator bool() const7360 explicit operator bool() const VULKAN_HPP_NOEXCEPT
7361 {
7362 return m_shaderModule != VK_NULL_HANDLE;
7363 }
7364
operator !() const7365 bool operator!() const VULKAN_HPP_NOEXCEPT
7366 {
7367 return m_shaderModule == VK_NULL_HANDLE;
7368 }
7369
7370 private:
7371 VkShaderModule m_shaderModule = {};
7372 };
7373
7374 template <>
7375 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eShaderModule>
7376 {
7377 using Type = VULKAN_HPP_NAMESPACE::ShaderModule;
7378 };
7379
7380
7381 template <>
7382 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eShaderModule>
7383 {
7384 using Type = VULKAN_HPP_NAMESPACE::ShaderModule;
7385 };
7386
7387
7388 template <>
7389 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::ShaderModule>
7390 {
7391 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
7392 };
7393
7394 class ValidationCacheEXT
7395 {
7396 public:
7397 using CType = VkValidationCacheEXT;
7398 using NativeType = VkValidationCacheEXT;
7399
7400 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eValidationCacheEXT;
7401 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eValidationCacheEXT;
7402
7403 public:
7404 VULKAN_HPP_CONSTEXPR ValidationCacheEXT() = default;
ValidationCacheEXT(std::nullptr_t)7405 VULKAN_HPP_CONSTEXPR ValidationCacheEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
7406 {}
ValidationCacheEXT(VkValidationCacheEXT validationCacheEXT)7407 VULKAN_HPP_TYPESAFE_EXPLICIT ValidationCacheEXT( VkValidationCacheEXT validationCacheEXT ) VULKAN_HPP_NOEXCEPT
7408 : m_validationCacheEXT( validationCacheEXT )
7409 {}
7410
7411 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkValidationCacheEXT validationCacheEXT)7412 ValidationCacheEXT & operator=(VkValidationCacheEXT validationCacheEXT) VULKAN_HPP_NOEXCEPT
7413 {
7414 m_validationCacheEXT = validationCacheEXT;
7415 return *this;
7416 }
7417 #endif
7418
operator =(std::nullptr_t)7419 ValidationCacheEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
7420 {
7421 m_validationCacheEXT = {};
7422 return *this;
7423 }
7424
7425 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
7426 auto operator<=>( ValidationCacheEXT const & ) const = default;
7427 #else
operator ==(ValidationCacheEXT const & rhs) const7428 bool operator==( ValidationCacheEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
7429 {
7430 return m_validationCacheEXT == rhs.m_validationCacheEXT;
7431 }
7432
operator !=(ValidationCacheEXT const & rhs) const7433 bool operator!=(ValidationCacheEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
7434 {
7435 return m_validationCacheEXT != rhs.m_validationCacheEXT;
7436 }
7437
operator <(ValidationCacheEXT const & rhs) const7438 bool operator<(ValidationCacheEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
7439 {
7440 return m_validationCacheEXT < rhs.m_validationCacheEXT;
7441 }
7442 #endif
7443
operator VkValidationCacheEXT() const7444 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkValidationCacheEXT() const VULKAN_HPP_NOEXCEPT
7445 {
7446 return m_validationCacheEXT;
7447 }
7448
operator bool() const7449 explicit operator bool() const VULKAN_HPP_NOEXCEPT
7450 {
7451 return m_validationCacheEXT != VK_NULL_HANDLE;
7452 }
7453
operator !() const7454 bool operator!() const VULKAN_HPP_NOEXCEPT
7455 {
7456 return m_validationCacheEXT == VK_NULL_HANDLE;
7457 }
7458
7459 private:
7460 VkValidationCacheEXT m_validationCacheEXT = {};
7461 };
7462
7463 template <>
7464 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eValidationCacheEXT>
7465 {
7466 using Type = VULKAN_HPP_NAMESPACE::ValidationCacheEXT;
7467 };
7468
7469
7470 template <>
7471 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eValidationCacheEXT>
7472 {
7473 using Type = VULKAN_HPP_NAMESPACE::ValidationCacheEXT;
7474 };
7475
7476
7477 template <>
7478 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::ValidationCacheEXT>
7479 {
7480 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
7481 };
7482
7483 class VideoSessionParametersKHR
7484 {
7485 public:
7486 using CType = VkVideoSessionParametersKHR;
7487 using NativeType = VkVideoSessionParametersKHR;
7488
7489 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionParametersKHR;
7490 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
7491
7492 public:
7493 VULKAN_HPP_CONSTEXPR VideoSessionParametersKHR() = default;
VideoSessionParametersKHR(std::nullptr_t)7494 VULKAN_HPP_CONSTEXPR VideoSessionParametersKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
7495 {}
VideoSessionParametersKHR(VkVideoSessionParametersKHR videoSessionParametersKHR)7496 VULKAN_HPP_TYPESAFE_EXPLICIT VideoSessionParametersKHR( VkVideoSessionParametersKHR videoSessionParametersKHR ) VULKAN_HPP_NOEXCEPT
7497 : m_videoSessionParametersKHR( videoSessionParametersKHR )
7498 {}
7499
7500 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkVideoSessionParametersKHR videoSessionParametersKHR)7501 VideoSessionParametersKHR & operator=(VkVideoSessionParametersKHR videoSessionParametersKHR) VULKAN_HPP_NOEXCEPT
7502 {
7503 m_videoSessionParametersKHR = videoSessionParametersKHR;
7504 return *this;
7505 }
7506 #endif
7507
operator =(std::nullptr_t)7508 VideoSessionParametersKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
7509 {
7510 m_videoSessionParametersKHR = {};
7511 return *this;
7512 }
7513
7514 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
7515 auto operator<=>( VideoSessionParametersKHR const & ) const = default;
7516 #else
operator ==(VideoSessionParametersKHR const & rhs) const7517 bool operator==( VideoSessionParametersKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
7518 {
7519 return m_videoSessionParametersKHR == rhs.m_videoSessionParametersKHR;
7520 }
7521
operator !=(VideoSessionParametersKHR const & rhs) const7522 bool operator!=(VideoSessionParametersKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
7523 {
7524 return m_videoSessionParametersKHR != rhs.m_videoSessionParametersKHR;
7525 }
7526
operator <(VideoSessionParametersKHR const & rhs) const7527 bool operator<(VideoSessionParametersKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
7528 {
7529 return m_videoSessionParametersKHR < rhs.m_videoSessionParametersKHR;
7530 }
7531 #endif
7532
operator VkVideoSessionParametersKHR() const7533 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkVideoSessionParametersKHR() const VULKAN_HPP_NOEXCEPT
7534 {
7535 return m_videoSessionParametersKHR;
7536 }
7537
operator bool() const7538 explicit operator bool() const VULKAN_HPP_NOEXCEPT
7539 {
7540 return m_videoSessionParametersKHR != VK_NULL_HANDLE;
7541 }
7542
operator !() const7543 bool operator!() const VULKAN_HPP_NOEXCEPT
7544 {
7545 return m_videoSessionParametersKHR == VK_NULL_HANDLE;
7546 }
7547
7548 private:
7549 VkVideoSessionParametersKHR m_videoSessionParametersKHR = {};
7550 };
7551
7552 template <>
7553 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionParametersKHR>
7554 {
7555 using Type = VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR;
7556 };
7557
7558
7559
7560 template <>
7561 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR>
7562 {
7563 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
7564 };
7565
7566 class Queue
7567 {
7568 public:
7569 using CType = VkQueue;
7570 using NativeType = VkQueue;
7571
7572 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eQueue;
7573 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueue;
7574
7575 public:
7576 VULKAN_HPP_CONSTEXPR Queue() = default;
Queue(std::nullptr_t)7577 VULKAN_HPP_CONSTEXPR Queue( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
7578 {}
Queue(VkQueue queue)7579 Queue( VkQueue queue ) VULKAN_HPP_NOEXCEPT
7580 : m_queue( queue )
7581 {}
7582
operator =(VkQueue queue)7583 Queue & operator=(VkQueue queue) VULKAN_HPP_NOEXCEPT
7584 {
7585 m_queue = queue;
7586 return *this;
7587 }
7588
operator =(std::nullptr_t)7589 Queue & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
7590 {
7591 m_queue = {};
7592 return *this;
7593 }
7594
7595 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
7596 auto operator<=>( Queue const & ) const = default;
7597 #else
operator ==(Queue const & rhs) const7598 bool operator==( Queue const & rhs ) const VULKAN_HPP_NOEXCEPT
7599 {
7600 return m_queue == rhs.m_queue;
7601 }
7602
operator !=(Queue const & rhs) const7603 bool operator!=(Queue const & rhs ) const VULKAN_HPP_NOEXCEPT
7604 {
7605 return m_queue != rhs.m_queue;
7606 }
7607
operator <(Queue const & rhs) const7608 bool operator<(Queue const & rhs ) const VULKAN_HPP_NOEXCEPT
7609 {
7610 return m_queue < rhs.m_queue;
7611 }
7612 #endif
7613
7614 //=== VK_VERSION_1_0 ===
7615
7616
7617 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7618 VULKAN_HPP_NODISCARD Result submit( uint32_t submitCount, const VULKAN_HPP_NAMESPACE::SubmitInfo * pSubmits, VULKAN_HPP_NAMESPACE::Fence fence, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7619 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7620 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7621 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type submit( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo> const & submits, VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7622 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7623
7624
7625 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
7626 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7627 VULKAN_HPP_NODISCARD Result waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7628 #else
7629 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7630 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7631 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7632
7633
7634 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7635 VULKAN_HPP_NODISCARD Result bindSparse( uint32_t bindInfoCount, const VULKAN_HPP_NAMESPACE::BindSparseInfo * pBindInfo, VULKAN_HPP_NAMESPACE::Fence fence, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7636 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7637 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7638 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type bindSparse( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindSparseInfo> const & bindInfo, VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7639 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7640
7641 //=== VK_VERSION_1_3 ===
7642
7643
7644 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7645 VULKAN_HPP_NODISCARD Result submit2( uint32_t submitCount, const VULKAN_HPP_NAMESPACE::SubmitInfo2 * pSubmits, VULKAN_HPP_NAMESPACE::Fence fence, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7646 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7647 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7648 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type submit2( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo2> const & submits, VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7649 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7650
7651 //=== VK_KHR_swapchain ===
7652
7653
7654 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7655 VULKAN_HPP_NODISCARD Result presentKHR( const VULKAN_HPP_NAMESPACE::PresentInfoKHR * pPresentInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7656 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7657 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7658 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result presentKHR( const VULKAN_HPP_NAMESPACE::PresentInfoKHR & presentInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7659 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7660
7661 //=== VK_EXT_debug_utils ===
7662
7663
7664 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7665 void beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7666 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7667 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7668 void beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7669 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7670
7671
7672 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7673 void endDebugUtilsLabelEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7674
7675
7676 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7677 void insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7678 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7679 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7680 void insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7681 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7682
7683 //=== VK_NV_device_diagnostic_checkpoints ===
7684
7685
7686 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7687 void getCheckpointDataNV( uint32_t * pCheckpointDataCount, VULKAN_HPP_NAMESPACE::CheckpointDataNV * pCheckpointData, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7688 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7689 template <typename CheckpointDataNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CheckpointDataNV>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7690 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CheckpointDataNV, CheckpointDataNVAllocator> getCheckpointDataNV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7691 template <typename CheckpointDataNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CheckpointDataNV>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = CheckpointDataNVAllocator, typename std::enable_if<std::is_same<typename B1::value_type, CheckpointDataNV>::value, int>::type = 0>
7692 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CheckpointDataNV, CheckpointDataNVAllocator> getCheckpointDataNV( CheckpointDataNVAllocator & checkpointDataNVAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7693 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7694
7695 //=== VK_INTEL_performance_query ===
7696
7697
7698 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
7699 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7700 VULKAN_HPP_NODISCARD Result setPerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7701 #else
7702 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7703 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type setPerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7704 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7705
7706 //=== VK_KHR_synchronization2 ===
7707
7708
7709 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7710 VULKAN_HPP_NODISCARD Result submit2KHR( uint32_t submitCount, const VULKAN_HPP_NAMESPACE::SubmitInfo2 * pSubmits, VULKAN_HPP_NAMESPACE::Fence fence, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7711 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7712 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7713 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type submit2KHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo2> const & submits, VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7714 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7715
7716
7717 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7718 void getCheckpointData2NV( uint32_t * pCheckpointDataCount, VULKAN_HPP_NAMESPACE::CheckpointData2NV * pCheckpointData, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7719 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7720 template <typename CheckpointData2NVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CheckpointData2NV>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7721 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CheckpointData2NV, CheckpointData2NVAllocator> getCheckpointData2NV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7722 template <typename CheckpointData2NVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CheckpointData2NV>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = CheckpointData2NVAllocator, typename std::enable_if<std::is_same<typename B1::value_type, CheckpointData2NV>::value, int>::type = 0>
7723 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CheckpointData2NV, CheckpointData2NVAllocator> getCheckpointData2NV( CheckpointData2NVAllocator & checkpointData2NVAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7724 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7725
7726 //=== VK_NV_low_latency2 ===
7727
7728
7729 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7730 void notifyOutOfBandNV( const VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeInfoNV * pQueueTypeInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7731 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7732 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7733 void notifyOutOfBandNV( const VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeInfoNV & queueTypeInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7734 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7735
operator VkQueue() const7736 operator VkQueue() const VULKAN_HPP_NOEXCEPT
7737 {
7738 return m_queue;
7739 }
7740
operator bool() const7741 explicit operator bool() const VULKAN_HPP_NOEXCEPT
7742 {
7743 return m_queue != VK_NULL_HANDLE;
7744 }
7745
operator !() const7746 bool operator!() const VULKAN_HPP_NOEXCEPT
7747 {
7748 return m_queue == VK_NULL_HANDLE;
7749 }
7750
7751 private:
7752 VkQueue m_queue = {};
7753 };
7754
7755 template <>
7756 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eQueue>
7757 {
7758 using Type = VULKAN_HPP_NAMESPACE::Queue;
7759 };
7760
7761
7762 template <>
7763 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueue>
7764 {
7765 using Type = VULKAN_HPP_NAMESPACE::Queue;
7766 };
7767
7768
7769 template <>
7770 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Queue>
7771 {
7772 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
7773 };
7774
7775 class Device
7776 {
7777 public:
7778 using CType = VkDevice;
7779 using NativeType = VkDevice;
7780
7781 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDevice;
7782 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDevice;
7783
7784 public:
7785 VULKAN_HPP_CONSTEXPR Device() = default;
Device(std::nullptr_t)7786 VULKAN_HPP_CONSTEXPR Device( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
7787 {}
Device(VkDevice device)7788 Device( VkDevice device ) VULKAN_HPP_NOEXCEPT
7789 : m_device( device )
7790 {}
7791
operator =(VkDevice device)7792 Device & operator=(VkDevice device) VULKAN_HPP_NOEXCEPT
7793 {
7794 m_device = device;
7795 return *this;
7796 }
7797
operator =(std::nullptr_t)7798 Device & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
7799 {
7800 m_device = {};
7801 return *this;
7802 }
7803
7804 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
7805 auto operator<=>( Device const & ) const = default;
7806 #else
operator ==(Device const & rhs) const7807 bool operator==( Device const & rhs ) const VULKAN_HPP_NOEXCEPT
7808 {
7809 return m_device == rhs.m_device;
7810 }
7811
operator !=(Device const & rhs) const7812 bool operator!=(Device const & rhs ) const VULKAN_HPP_NOEXCEPT
7813 {
7814 return m_device != rhs.m_device;
7815 }
7816
operator <(Device const & rhs) const7817 bool operator<(Device const & rhs ) const VULKAN_HPP_NOEXCEPT
7818 {
7819 return m_device < rhs.m_device;
7820 }
7821 #endif
7822
7823 //=== VK_VERSION_1_0 ===
7824
7825
7826 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7827 PFN_vkVoidFunction getProcAddr( const char * pName, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7828 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7829 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7830 PFN_vkVoidFunction getProcAddr( const std::string & name, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7831 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7832
7833
7834 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7835 void destroy( const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7836 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7837 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7838 void destroy( Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7839 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7840
7841
7842 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7843 void getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex, VULKAN_HPP_NAMESPACE::Queue * pQueue, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7844 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7845 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7846 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Queue getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7847 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7848
7849
7850 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
7851 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7852 VULKAN_HPP_NODISCARD Result waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7853 #else
7854 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7855 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7856 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7857
7858
7859 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7860 VULKAN_HPP_NODISCARD Result allocateMemory( const VULKAN_HPP_NAMESPACE::MemoryAllocateInfo * pAllocateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::DeviceMemory * pMemory, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7861 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7862 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7863 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceMemory>::type allocateMemory( const VULKAN_HPP_NAMESPACE::MemoryAllocateInfo & allocateInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7864 # ifndef VULKAN_HPP_NO_SMART_HANDLE
7865 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7866 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DeviceMemory, Dispatch>>::type allocateMemoryUnique( const VULKAN_HPP_NAMESPACE::MemoryAllocateInfo & allocateInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7867 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
7868 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7869
7870
7871 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7872 void freeMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7873 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7874 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7875 void freeMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7876 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7877
7878
7879 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7880 void ( free )( VULKAN_HPP_NAMESPACE::DeviceMemory memory, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7881 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7882 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7883 void ( free )( VULKAN_HPP_NAMESPACE::DeviceMemory memory, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7884 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7885
7886
7887 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7888 VULKAN_HPP_NODISCARD Result mapMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::DeviceSize size, VULKAN_HPP_NAMESPACE::MemoryMapFlags flags, void ** ppData, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7889 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7890 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7891 VULKAN_HPP_NODISCARD typename ResultValueType<void *>::type mapMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::DeviceSize size, VULKAN_HPP_NAMESPACE::MemoryMapFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7892 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7893
7894
7895 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7896 void unmapMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7897
7898
7899 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7900 VULKAN_HPP_NODISCARD Result flushMappedMemoryRanges( uint32_t memoryRangeCount, const VULKAN_HPP_NAMESPACE::MappedMemoryRange * pMemoryRanges, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7901 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7902 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7903 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type flushMappedMemoryRanges( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const & memoryRanges, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7904 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7905
7906
7907 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7908 VULKAN_HPP_NODISCARD Result invalidateMappedMemoryRanges( uint32_t memoryRangeCount, const VULKAN_HPP_NAMESPACE::MappedMemoryRange * pMemoryRanges, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7909 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7910 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7911 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type invalidateMappedMemoryRanges( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const & memoryRanges, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7912 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7913
7914
7915 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7916 void getMemoryCommitment( VULKAN_HPP_NAMESPACE::DeviceMemory memory, VULKAN_HPP_NAMESPACE::DeviceSize * pCommittedMemoryInBytes, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7917 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7918 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7919 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceSize getMemoryCommitment( VULKAN_HPP_NAMESPACE::DeviceMemory memory, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7920 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7921
7922
7923 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
7924 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7925 VULKAN_HPP_NODISCARD Result bindBufferMemory( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceMemory memory, VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7926 #else
7927 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7928 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type bindBufferMemory( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceMemory memory, VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7929 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7930
7931
7932 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
7933 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7934 VULKAN_HPP_NODISCARD Result bindImageMemory( VULKAN_HPP_NAMESPACE::Image image, VULKAN_HPP_NAMESPACE::DeviceMemory memory, VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7935 #else
7936 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7937 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type bindImageMemory( VULKAN_HPP_NAMESPACE::Image image, VULKAN_HPP_NAMESPACE::DeviceMemory memory, VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7938 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7939
7940
7941 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7942 void getBufferMemoryRequirements( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::MemoryRequirements * pMemoryRequirements, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7943 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7944 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7945 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements getBufferMemoryRequirements( VULKAN_HPP_NAMESPACE::Buffer buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7946 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7947
7948
7949 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7950 void getImageMemoryRequirements( VULKAN_HPP_NAMESPACE::Image image, VULKAN_HPP_NAMESPACE::MemoryRequirements * pMemoryRequirements, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7951 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7952 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7953 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements getImageMemoryRequirements( VULKAN_HPP_NAMESPACE::Image image, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7954 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7955
7956
7957 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7958 void getImageSparseMemoryRequirements( VULKAN_HPP_NAMESPACE::Image image, uint32_t * pSparseMemoryRequirementCount, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements * pSparseMemoryRequirements, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7959 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7960 template <typename SparseImageMemoryRequirementsAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7961 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator> getImageSparseMemoryRequirements( VULKAN_HPP_NAMESPACE::Image image, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7962 template <typename SparseImageMemoryRequirementsAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = SparseImageMemoryRequirementsAllocator, typename std::enable_if<std::is_same<typename B1::value_type, SparseImageMemoryRequirements>::value, int>::type = 0>
7963 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator> getImageSparseMemoryRequirements( VULKAN_HPP_NAMESPACE::Image image, SparseImageMemoryRequirementsAllocator & sparseImageMemoryRequirementsAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7964 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7965
7966
7967 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7968 VULKAN_HPP_NODISCARD Result createFence( const VULKAN_HPP_NAMESPACE::FenceCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::Fence * pFence, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7969 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7970 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7971 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Fence>::type createFence( const VULKAN_HPP_NAMESPACE::FenceCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7972 # ifndef VULKAN_HPP_NO_SMART_HANDLE
7973 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7974 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>>::type createFenceUnique( const VULKAN_HPP_NAMESPACE::FenceCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7975 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
7976 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7977
7978
7979 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7980 void destroyFence( VULKAN_HPP_NAMESPACE::Fence fence, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7981 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7982 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7983 void destroyFence( VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7984 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7985
7986
7987 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7988 void destroy( VULKAN_HPP_NAMESPACE::Fence fence, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7989 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7990 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7991 void destroy( VULKAN_HPP_NAMESPACE::Fence fence, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7992 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7993
7994
7995 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7996 VULKAN_HPP_NODISCARD Result resetFences( uint32_t fenceCount, const VULKAN_HPP_NAMESPACE::Fence * pFences, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7997 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7998 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7999 typename ResultValueType<void>::type resetFences( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const & fences, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8000 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8001
8002
8003 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
8004 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8005 VULKAN_HPP_NODISCARD Result getFenceStatus( VULKAN_HPP_NAMESPACE::Fence fence, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8006 #else
8007 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8008 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result getFenceStatus( VULKAN_HPP_NAMESPACE::Fence fence, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8009 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8010
8011
8012 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8013 VULKAN_HPP_NODISCARD Result waitForFences( uint32_t fenceCount, const VULKAN_HPP_NAMESPACE::Fence * pFences, VULKAN_HPP_NAMESPACE::Bool32 waitAll, uint64_t timeout, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8014 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8015 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8016 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result waitForFences( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const & fences, VULKAN_HPP_NAMESPACE::Bool32 waitAll, uint64_t timeout, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8017 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8018
8019
8020 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8021 VULKAN_HPP_NODISCARD Result createSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::Semaphore * pSemaphore, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8022 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8023 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8024 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Semaphore>::type createSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8025 # ifndef VULKAN_HPP_NO_SMART_HANDLE
8026 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8027 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Semaphore, Dispatch>>::type createSemaphoreUnique( const VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8028 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
8029 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8030
8031
8032 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8033 void destroySemaphore( VULKAN_HPP_NAMESPACE::Semaphore semaphore, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8034 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8035 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8036 void destroySemaphore( VULKAN_HPP_NAMESPACE::Semaphore semaphore VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8037 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8038
8039
8040 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8041 void destroy( VULKAN_HPP_NAMESPACE::Semaphore semaphore, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8042 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8043 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8044 void destroy( VULKAN_HPP_NAMESPACE::Semaphore semaphore, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8045 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8046
8047
8048 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8049 VULKAN_HPP_NODISCARD Result createEvent( const VULKAN_HPP_NAMESPACE::EventCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::Event * pEvent, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8050 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8051 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8052 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Event>::type createEvent( const VULKAN_HPP_NAMESPACE::EventCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8053 # ifndef VULKAN_HPP_NO_SMART_HANDLE
8054 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8055 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Event, Dispatch>>::type createEventUnique( const VULKAN_HPP_NAMESPACE::EventCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8056 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
8057 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8058
8059
8060 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8061 void destroyEvent( VULKAN_HPP_NAMESPACE::Event event, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8062 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8063 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8064 void destroyEvent( VULKAN_HPP_NAMESPACE::Event event VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8065 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8066
8067
8068 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8069 void destroy( VULKAN_HPP_NAMESPACE::Event event, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8070 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8071 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8072 void destroy( VULKAN_HPP_NAMESPACE::Event event, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8073 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8074
8075
8076 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
8077 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8078 VULKAN_HPP_NODISCARD Result getEventStatus( VULKAN_HPP_NAMESPACE::Event event, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8079 #else
8080 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8081 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result getEventStatus( VULKAN_HPP_NAMESPACE::Event event, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8082 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8083
8084
8085 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
8086 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8087 VULKAN_HPP_NODISCARD Result setEvent( VULKAN_HPP_NAMESPACE::Event event, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8088 #else
8089 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8090 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type setEvent( VULKAN_HPP_NAMESPACE::Event event, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8091 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8092
8093
8094 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
8095 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8096 VULKAN_HPP_NODISCARD Result resetEvent( VULKAN_HPP_NAMESPACE::Event event, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8097 #else
8098 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8099 typename ResultValueType<void>::type resetEvent( VULKAN_HPP_NAMESPACE::Event event, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8100 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8101
8102
8103 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8104 VULKAN_HPP_NODISCARD Result createQueryPool( const VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::QueryPool * pQueryPool, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8105 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8106 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8107 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::QueryPool>::type createQueryPool( const VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8108 # ifndef VULKAN_HPP_NO_SMART_HANDLE
8109 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8110 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::QueryPool, Dispatch>>::type createQueryPoolUnique( const VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8111 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
8112 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8113
8114
8115 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8116 void destroyQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8117 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8118 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8119 void destroyQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8120 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8121
8122
8123 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8124 void destroy( VULKAN_HPP_NAMESPACE::QueryPool queryPool, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8125 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8126 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8127 void destroy( VULKAN_HPP_NAMESPACE::QueryPool queryPool, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8128 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8129
8130
8131 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8132 VULKAN_HPP_NODISCARD Result getQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void * pData, VULKAN_HPP_NAMESPACE::DeviceSize stride, VULKAN_HPP_NAMESPACE::QueryResultFlags flags, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8133 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8134 template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8135 VULKAN_HPP_NODISCARD ResultValue<std::vector<DataType, DataTypeAllocator>> getQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, VULKAN_HPP_NAMESPACE::DeviceSize stride, VULKAN_HPP_NAMESPACE::QueryResultFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8136 template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8137 VULKAN_HPP_NODISCARD ResultValue<DataType> getQueryPoolResult( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VULKAN_HPP_NAMESPACE::DeviceSize stride, VULKAN_HPP_NAMESPACE::QueryResultFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8138 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8139
8140
8141 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8142 VULKAN_HPP_NODISCARD Result createBuffer( const VULKAN_HPP_NAMESPACE::BufferCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::Buffer * pBuffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8143 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8144 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8145 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Buffer>::type createBuffer( const VULKAN_HPP_NAMESPACE::BufferCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8146 # ifndef VULKAN_HPP_NO_SMART_HANDLE
8147 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8148 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Buffer, Dispatch>>::type createBufferUnique( const VULKAN_HPP_NAMESPACE::BufferCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8149 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
8150 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8151
8152
8153 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8154 void destroyBuffer( VULKAN_HPP_NAMESPACE::Buffer buffer, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8155 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8156 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8157 void destroyBuffer( VULKAN_HPP_NAMESPACE::Buffer buffer VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8158 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8159
8160
8161 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8162 void destroy( VULKAN_HPP_NAMESPACE::Buffer buffer, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8163 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8164 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8165 void destroy( VULKAN_HPP_NAMESPACE::Buffer buffer, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8166 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8167
8168
8169 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8170 VULKAN_HPP_NODISCARD Result createBufferView( const VULKAN_HPP_NAMESPACE::BufferViewCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::BufferView * pView, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8171 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8172 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8173 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::BufferView>::type createBufferView( const VULKAN_HPP_NAMESPACE::BufferViewCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8174 # ifndef VULKAN_HPP_NO_SMART_HANDLE
8175 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8176 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::BufferView, Dispatch>>::type createBufferViewUnique( const VULKAN_HPP_NAMESPACE::BufferViewCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8177 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
8178 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8179
8180
8181 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8182 void destroyBufferView( VULKAN_HPP_NAMESPACE::BufferView bufferView, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8183 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8184 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8185 void destroyBufferView( VULKAN_HPP_NAMESPACE::BufferView bufferView VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8186 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8187
8188
8189 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8190 void destroy( VULKAN_HPP_NAMESPACE::BufferView bufferView, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8191 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8192 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8193 void destroy( VULKAN_HPP_NAMESPACE::BufferView bufferView, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8194 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8195
8196
8197 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8198 VULKAN_HPP_NODISCARD Result createImage( const VULKAN_HPP_NAMESPACE::ImageCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::Image * pImage, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8199 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8200 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8201 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Image>::type createImage( const VULKAN_HPP_NAMESPACE::ImageCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8202 # ifndef VULKAN_HPP_NO_SMART_HANDLE
8203 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8204 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Image, Dispatch>>::type createImageUnique( const VULKAN_HPP_NAMESPACE::ImageCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8205 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
8206 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8207
8208
8209 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8210 void destroyImage( VULKAN_HPP_NAMESPACE::Image image, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8211 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8212 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8213 void destroyImage( VULKAN_HPP_NAMESPACE::Image image VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8214 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8215
8216
8217 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8218 void destroy( VULKAN_HPP_NAMESPACE::Image image, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8219 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8220 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8221 void destroy( VULKAN_HPP_NAMESPACE::Image image, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8222 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8223
8224
8225 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8226 void getImageSubresourceLayout( VULKAN_HPP_NAMESPACE::Image image, const VULKAN_HPP_NAMESPACE::ImageSubresource * pSubresource, VULKAN_HPP_NAMESPACE::SubresourceLayout * pLayout, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8227 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8228 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8229 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SubresourceLayout getImageSubresourceLayout( VULKAN_HPP_NAMESPACE::Image image, const VULKAN_HPP_NAMESPACE::ImageSubresource & subresource, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8230 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8231
8232
8233 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8234 VULKAN_HPP_NODISCARD Result createImageView( const VULKAN_HPP_NAMESPACE::ImageViewCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::ImageView * pView, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8235 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8236 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8237 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageView>::type createImageView( const VULKAN_HPP_NAMESPACE::ImageViewCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8238 # ifndef VULKAN_HPP_NO_SMART_HANDLE
8239 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8240 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ImageView, Dispatch>>::type createImageViewUnique( const VULKAN_HPP_NAMESPACE::ImageViewCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8241 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
8242 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8243
8244
8245 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8246 void destroyImageView( VULKAN_HPP_NAMESPACE::ImageView imageView, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8247 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8248 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8249 void destroyImageView( VULKAN_HPP_NAMESPACE::ImageView imageView VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8250 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8251
8252
8253 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8254 void destroy( VULKAN_HPP_NAMESPACE::ImageView imageView, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8255 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8256 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8257 void destroy( VULKAN_HPP_NAMESPACE::ImageView imageView, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8258 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8259
8260
8261 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8262 VULKAN_HPP_NODISCARD Result createShaderModule( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::ShaderModule * pShaderModule, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8263 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8264 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8265 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ShaderModule>::type createShaderModule( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8266 # ifndef VULKAN_HPP_NO_SMART_HANDLE
8267 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8268 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderModule, Dispatch>>::type createShaderModuleUnique( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8269 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
8270 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8271
8272
8273 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8274 void destroyShaderModule( VULKAN_HPP_NAMESPACE::ShaderModule shaderModule, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8275 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8276 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8277 void destroyShaderModule( VULKAN_HPP_NAMESPACE::ShaderModule shaderModule VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8278 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8279
8280
8281 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8282 void destroy( VULKAN_HPP_NAMESPACE::ShaderModule shaderModule, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8283 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8284 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8285 void destroy( VULKAN_HPP_NAMESPACE::ShaderModule shaderModule, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8286 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8287
8288
8289 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8290 VULKAN_HPP_NODISCARD Result createPipelineCache( const VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::PipelineCache * pPipelineCache, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8291 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8292 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8293 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::PipelineCache>::type createPipelineCache( const VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8294 # ifndef VULKAN_HPP_NO_SMART_HANDLE
8295 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8296 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineCache, Dispatch>>::type createPipelineCacheUnique( const VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8297 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
8298 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8299
8300
8301 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8302 void destroyPipelineCache( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8303 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8304 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8305 void destroyPipelineCache( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8306 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8307
8308
8309 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8310 void destroy( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8311 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8312 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8313 void destroy( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8314 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8315
8316
8317 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8318 VULKAN_HPP_NODISCARD Result getPipelineCacheData( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, size_t * pDataSize, void * pData, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8319 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8320 template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8321 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type getPipelineCacheData( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8322 template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = Uint8_tAllocator, typename std::enable_if<std::is_same<typename B1::value_type, uint8_t>::value, int>::type = 0>
8323 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type getPipelineCacheData( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, Uint8_tAllocator & uint8_tAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8324 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8325
8326
8327 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8328 VULKAN_HPP_NODISCARD Result mergePipelineCaches( VULKAN_HPP_NAMESPACE::PipelineCache dstCache, uint32_t srcCacheCount, const VULKAN_HPP_NAMESPACE::PipelineCache * pSrcCaches, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8329 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8330 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8331 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type mergePipelineCaches( VULKAN_HPP_NAMESPACE::PipelineCache dstCache, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::PipelineCache> const & srcCaches, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8332 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8333
8334
8335 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8336 VULKAN_HPP_NODISCARD Result createGraphicsPipelines( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, uint32_t createInfoCount, const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo * pCreateInfos, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::Pipeline * pPipelines, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8337 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8338 template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8339 VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>> createGraphicsPipelines( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8340 template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B0 = PipelineAllocator, typename std::enable_if<std::is_same<typename B0::value_type, Pipeline>::value, int>::type = 0>
8341 VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>> createGraphicsPipelines( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, PipelineAllocator & pipelineAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8342 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8343 VULKAN_HPP_NODISCARD ResultValue<VULKAN_HPP_NAMESPACE::Pipeline> createGraphicsPipeline( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8344 # ifndef VULKAN_HPP_NO_SMART_HANDLE
8345 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>>
8346 VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>> createGraphicsPipelinesUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8347 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>, typename B0 = PipelineAllocator, typename std::enable_if<std::is_same<typename B0::value_type, UniqueHandle<Pipeline, Dispatch>>::value, int>::type = 0>
8348 VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>> createGraphicsPipelinesUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, PipelineAllocator & pipelineAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8349 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8350 VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>> createGraphicsPipelineUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8351 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
8352 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8353
8354
8355 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8356 VULKAN_HPP_NODISCARD Result createComputePipelines( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, uint32_t createInfoCount, const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo * pCreateInfos, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::Pipeline * pPipelines, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8357 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8358 template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8359 VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>> createComputePipelines( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8360 template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B0 = PipelineAllocator, typename std::enable_if<std::is_same<typename B0::value_type, Pipeline>::value, int>::type = 0>
8361 VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>> createComputePipelines( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, PipelineAllocator & pipelineAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8362 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8363 VULKAN_HPP_NODISCARD ResultValue<VULKAN_HPP_NAMESPACE::Pipeline> createComputePipeline( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8364 # ifndef VULKAN_HPP_NO_SMART_HANDLE
8365 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>>
8366 VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>> createComputePipelinesUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8367 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>, typename B0 = PipelineAllocator, typename std::enable_if<std::is_same<typename B0::value_type, UniqueHandle<Pipeline, Dispatch>>::value, int>::type = 0>
8368 VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>> createComputePipelinesUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, PipelineAllocator & pipelineAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8369 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8370 VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>> createComputePipelineUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8371 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
8372 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8373
8374
8375 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8376 void destroyPipeline( VULKAN_HPP_NAMESPACE::Pipeline pipeline, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8377 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8378 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8379 void destroyPipeline( VULKAN_HPP_NAMESPACE::Pipeline pipeline VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8380 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8381
8382
8383 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8384 void destroy( VULKAN_HPP_NAMESPACE::Pipeline pipeline, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8385 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8386 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8387 void destroy( VULKAN_HPP_NAMESPACE::Pipeline pipeline, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8388 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8389
8390
8391 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8392 VULKAN_HPP_NODISCARD Result createPipelineLayout( const VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::PipelineLayout * pPipelineLayout, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8393 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8394 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8395 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::PipelineLayout>::type createPipelineLayout( const VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8396 # ifndef VULKAN_HPP_NO_SMART_HANDLE
8397 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8398 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineLayout, Dispatch>>::type createPipelineLayoutUnique( const VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8399 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
8400 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8401
8402
8403 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8404 void destroyPipelineLayout( VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8405 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8406 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8407 void destroyPipelineLayout( VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8408 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8409
8410
8411 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8412 void destroy( VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8413 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8414 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8415 void destroy( VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8416 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8417
8418
8419 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8420 VULKAN_HPP_NODISCARD Result createSampler( const VULKAN_HPP_NAMESPACE::SamplerCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::Sampler * pSampler, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8421 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8422 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8423 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Sampler>::type createSampler( const VULKAN_HPP_NAMESPACE::SamplerCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8424 # ifndef VULKAN_HPP_NO_SMART_HANDLE
8425 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8426 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Sampler, Dispatch>>::type createSamplerUnique( const VULKAN_HPP_NAMESPACE::SamplerCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8427 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
8428 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8429
8430
8431 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8432 void destroySampler( VULKAN_HPP_NAMESPACE::Sampler sampler, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8433 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8434 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8435 void destroySampler( VULKAN_HPP_NAMESPACE::Sampler sampler VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8436 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8437
8438
8439 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8440 void destroy( VULKAN_HPP_NAMESPACE::Sampler sampler, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8441 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8442 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8443 void destroy( VULKAN_HPP_NAMESPACE::Sampler sampler, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8444 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8445
8446
8447 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8448 VULKAN_HPP_NODISCARD Result createDescriptorSetLayout( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::DescriptorSetLayout * pSetLayout, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8449 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8450 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8451 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DescriptorSetLayout>::type createDescriptorSetLayout( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8452 # ifndef VULKAN_HPP_NO_SMART_HANDLE
8453 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8454 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSetLayout, Dispatch>>::type createDescriptorSetLayoutUnique( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8455 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
8456 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8457
8458
8459 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8460 void destroyDescriptorSetLayout( VULKAN_HPP_NAMESPACE::DescriptorSetLayout descriptorSetLayout, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8461 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8462 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8463 void destroyDescriptorSetLayout( VULKAN_HPP_NAMESPACE::DescriptorSetLayout descriptorSetLayout VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8464 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8465
8466
8467 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8468 void destroy( VULKAN_HPP_NAMESPACE::DescriptorSetLayout descriptorSetLayout, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8469 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8470 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8471 void destroy( VULKAN_HPP_NAMESPACE::DescriptorSetLayout descriptorSetLayout, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8472 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8473
8474
8475 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8476 VULKAN_HPP_NODISCARD Result createDescriptorPool( const VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::DescriptorPool * pDescriptorPool, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8477 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8478 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8479 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DescriptorPool>::type createDescriptorPool( const VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8480 # ifndef VULKAN_HPP_NO_SMART_HANDLE
8481 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8482 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorPool, Dispatch>>::type createDescriptorPoolUnique( const VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8483 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
8484 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8485
8486
8487 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8488 void destroyDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8489 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8490 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8491 void destroyDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8492 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8493
8494
8495 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8496 void destroy( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8497 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8498 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8499 void destroy( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8500 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8501
8502
8503 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
8504 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8505 Result resetDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlags flags, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8506 #else
8507 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8508 void resetDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8509 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8510
8511
8512 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8513 VULKAN_HPP_NODISCARD Result allocateDescriptorSets( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo * pAllocateInfo, VULKAN_HPP_NAMESPACE::DescriptorSet * pDescriptorSets, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8514 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8515 template <typename DescriptorSetAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DescriptorSet>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8516 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DescriptorSet, DescriptorSetAllocator>>::type allocateDescriptorSets( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo & allocateInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8517 template <typename DescriptorSetAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DescriptorSet>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B0 = DescriptorSetAllocator, typename std::enable_if<std::is_same<typename B0::value_type, DescriptorSet>::value, int>::type = 0>
8518 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DescriptorSet, DescriptorSetAllocator>>::type allocateDescriptorSets( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo & allocateInfo, DescriptorSetAllocator & descriptorSetAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8519 # ifndef VULKAN_HPP_NO_SMART_HANDLE
8520 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename DescriptorSetAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSet, Dispatch>>>
8521 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSet, Dispatch>, DescriptorSetAllocator>>::type allocateDescriptorSetsUnique( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo & allocateInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8522 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename DescriptorSetAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSet, Dispatch>>, typename B0 = DescriptorSetAllocator, typename std::enable_if<std::is_same<typename B0::value_type, UniqueHandle<DescriptorSet, Dispatch>>::value, int>::type = 0>
8523 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSet, Dispatch>, DescriptorSetAllocator>>::type allocateDescriptorSetsUnique( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo & allocateInfo, DescriptorSetAllocator & descriptorSetAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8524 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
8525 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8526
8527
8528 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8529 Result freeDescriptorSets( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, uint32_t descriptorSetCount, const VULKAN_HPP_NAMESPACE::DescriptorSet * pDescriptorSets, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8530 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8531 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8532 void freeDescriptorSets( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const & descriptorSets, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8533 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8534
8535
8536 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8537 Result ( free )( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, uint32_t descriptorSetCount, const VULKAN_HPP_NAMESPACE::DescriptorSet * pDescriptorSets, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8538 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8539 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8540 void ( free )( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const & descriptorSets, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8541 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8542
8543
8544 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8545 void updateDescriptorSets( uint32_t descriptorWriteCount, const VULKAN_HPP_NAMESPACE::WriteDescriptorSet * pDescriptorWrites, uint32_t descriptorCopyCount, const VULKAN_HPP_NAMESPACE::CopyDescriptorSet * pDescriptorCopies, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8546 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8547 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8548 void updateDescriptorSets( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CopyDescriptorSet> const & descriptorCopies, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8549 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8550
8551
8552 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8553 VULKAN_HPP_NODISCARD Result createFramebuffer( const VULKAN_HPP_NAMESPACE::FramebufferCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::Framebuffer * pFramebuffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8554 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8555 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8556 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Framebuffer>::type createFramebuffer( const VULKAN_HPP_NAMESPACE::FramebufferCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8557 # ifndef VULKAN_HPP_NO_SMART_HANDLE
8558 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8559 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Framebuffer, Dispatch>>::type createFramebufferUnique( const VULKAN_HPP_NAMESPACE::FramebufferCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8560 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
8561 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8562
8563
8564 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8565 void destroyFramebuffer( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8566 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8567 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8568 void destroyFramebuffer( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8569 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8570
8571
8572 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8573 void destroy( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8574 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8575 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8576 void destroy( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8577 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8578
8579
8580 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8581 VULKAN_HPP_NODISCARD Result createRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::RenderPass * pRenderPass, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8582 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8583 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8584 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::RenderPass>::type createRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8585 # ifndef VULKAN_HPP_NO_SMART_HANDLE
8586 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8587 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>>::type createRenderPassUnique( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8588 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
8589 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8590
8591
8592 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8593 void destroyRenderPass( VULKAN_HPP_NAMESPACE::RenderPass renderPass, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8594 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8595 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8596 void destroyRenderPass( VULKAN_HPP_NAMESPACE::RenderPass renderPass VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8597 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8598
8599
8600 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8601 void destroy( VULKAN_HPP_NAMESPACE::RenderPass renderPass, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8602 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8603 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8604 void destroy( VULKAN_HPP_NAMESPACE::RenderPass renderPass, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8605 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8606
8607
8608 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8609 void getRenderAreaGranularity( VULKAN_HPP_NAMESPACE::RenderPass renderPass, VULKAN_HPP_NAMESPACE::Extent2D * pGranularity, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8610 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8611 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8612 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Extent2D getRenderAreaGranularity( VULKAN_HPP_NAMESPACE::RenderPass renderPass, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8613 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8614
8615
8616 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8617 VULKAN_HPP_NODISCARD Result createCommandPool( const VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::CommandPool * pCommandPool, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8618 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8619 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8620 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::CommandPool>::type createCommandPool( const VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8621 # ifndef VULKAN_HPP_NO_SMART_HANDLE
8622 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8623 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandPool, Dispatch>>::type createCommandPoolUnique( const VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8624 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
8625 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8626
8627
8628 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8629 void destroyCommandPool( VULKAN_HPP_NAMESPACE::CommandPool commandPool, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8630 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8631 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8632 void destroyCommandPool( VULKAN_HPP_NAMESPACE::CommandPool commandPool VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8633 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8634
8635
8636 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8637 void destroy( VULKAN_HPP_NAMESPACE::CommandPool commandPool, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8638 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8639 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8640 void destroy( VULKAN_HPP_NAMESPACE::CommandPool commandPool, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8641 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8642
8643
8644 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
8645 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8646 VULKAN_HPP_NODISCARD Result resetCommandPool( VULKAN_HPP_NAMESPACE::CommandPool commandPool, VULKAN_HPP_NAMESPACE::CommandPoolResetFlags flags, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8647 #else
8648 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8649 typename ResultValueType<void>::type resetCommandPool( VULKAN_HPP_NAMESPACE::CommandPool commandPool, VULKAN_HPP_NAMESPACE::CommandPoolResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8650 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8651
8652
8653 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8654 VULKAN_HPP_NODISCARD Result allocateCommandBuffers( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo * pAllocateInfo, VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8655 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8656 template <typename CommandBufferAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CommandBuffer>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8657 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CommandBuffer, CommandBufferAllocator>>::type allocateCommandBuffers( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo & allocateInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8658 template <typename CommandBufferAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CommandBuffer>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B0 = CommandBufferAllocator, typename std::enable_if<std::is_same<typename B0::value_type, CommandBuffer>::value, int>::type = 0>
8659 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CommandBuffer, CommandBufferAllocator>>::type allocateCommandBuffers( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo & allocateInfo, CommandBufferAllocator & commandBufferAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8660 # ifndef VULKAN_HPP_NO_SMART_HANDLE
8661 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename CommandBufferAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandBuffer, Dispatch>>>
8662 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandBuffer, Dispatch>, CommandBufferAllocator>>::type allocateCommandBuffersUnique( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo & allocateInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8663 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename CommandBufferAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandBuffer, Dispatch>>, typename B0 = CommandBufferAllocator, typename std::enable_if<std::is_same<typename B0::value_type, UniqueHandle<CommandBuffer, Dispatch>>::value, int>::type = 0>
8664 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandBuffer, Dispatch>, CommandBufferAllocator>>::type allocateCommandBuffersUnique( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo & allocateInfo, CommandBufferAllocator & commandBufferAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8665 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
8666 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8667
8668
8669 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8670 void freeCommandBuffers( VULKAN_HPP_NAMESPACE::CommandPool commandPool, uint32_t commandBufferCount, const VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8671 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8672 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8673 void freeCommandBuffers( VULKAN_HPP_NAMESPACE::CommandPool commandPool, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8674 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8675
8676
8677 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8678 void ( free )( VULKAN_HPP_NAMESPACE::CommandPool commandPool, uint32_t commandBufferCount, const VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8679 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8680 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8681 void ( free )( VULKAN_HPP_NAMESPACE::CommandPool commandPool, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8682 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8683
8684 //=== VK_VERSION_1_1 ===
8685
8686
8687 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8688 VULKAN_HPP_NODISCARD Result bindBufferMemory2( uint32_t bindInfoCount, const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo * pBindInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8689 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8690 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8691 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type bindBufferMemory2( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const & bindInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8692 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8693
8694
8695 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8696 VULKAN_HPP_NODISCARD Result bindImageMemory2( uint32_t bindInfoCount, const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo * pBindInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8697 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8698 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8699 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type bindImageMemory2( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const & bindInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8700 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8701
8702
8703 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8704 void getGroupPeerMemoryFeatures( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags * pPeerMemoryFeatures, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8705 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8706 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8707 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags getGroupPeerMemoryFeatures( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8708 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8709
8710
8711 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8712 void getImageMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 * pInfo, VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8713 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8714 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8715 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getImageMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8716 template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8717 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getImageMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8718 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8719
8720
8721 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8722 void getBufferMemoryRequirements2( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 * pInfo, VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8723 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8724 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8725 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getBufferMemoryRequirements2( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8726 template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8727 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getBufferMemoryRequirements2( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8728 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8729
8730
8731 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8732 void getImageSparseMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 * pInfo, uint32_t * pSparseMemoryRequirementCount, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 * pSparseMemoryRequirements, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8733 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8734 template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8735 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> getImageSparseMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8736 template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = SparseImageMemoryRequirements2Allocator, typename std::enable_if<std::is_same<typename B1::value_type, SparseImageMemoryRequirements2>::value, int>::type = 0>
8737 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> getImageSparseMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info, SparseImageMemoryRequirements2Allocator & sparseImageMemoryRequirements2Allocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8738 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8739
8740
8741 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8742 void trimCommandPool( VULKAN_HPP_NAMESPACE::CommandPool commandPool, VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8743
8744
8745 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8746 void getQueue2( const VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 * pQueueInfo, VULKAN_HPP_NAMESPACE::Queue * pQueue, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8747 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8748 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8749 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Queue getQueue2( const VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 & queueInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8750 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8751
8752
8753 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8754 VULKAN_HPP_NODISCARD Result createSamplerYcbcrConversion( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion * pYcbcrConversion, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8755 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8756 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8757 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>::type createSamplerYcbcrConversion( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8758 # ifndef VULKAN_HPP_NO_SMART_HANDLE
8759 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8760 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion, Dispatch>>::type createSamplerYcbcrConversionUnique( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8761 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
8762 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8763
8764
8765 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8766 void destroySamplerYcbcrConversion( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8767 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8768 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8769 void destroySamplerYcbcrConversion( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8770 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8771
8772
8773 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8774 void destroy( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8775 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8776 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8777 void destroy( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8778 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8779
8780
8781 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8782 VULKAN_HPP_NODISCARD Result createDescriptorUpdateTemplate( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate * pDescriptorUpdateTemplate, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8783 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8784 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8785 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate>::type createDescriptorUpdateTemplate( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8786 # ifndef VULKAN_HPP_NO_SMART_HANDLE
8787 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8788 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate, Dispatch>>::type createDescriptorUpdateTemplateUnique( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8789 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
8790 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8791
8792
8793 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8794 void destroyDescriptorUpdateTemplate( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8795 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8796 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8797 void destroyDescriptorUpdateTemplate( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8798 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8799
8800
8801 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8802 void destroy( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8803 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8804 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8805 void destroy( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8806 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8807
8808
8809 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8810 void updateDescriptorSetWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet, VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, const void * pData, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8811 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8812 template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8813 void updateDescriptorSetWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet, VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, DataType const & data, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8814 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8815
8816
8817 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8818 void getDescriptorSetLayoutSupport( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo * pCreateInfo, VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport * pSupport, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8819 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8820 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8821 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport getDescriptorSetLayoutSupport( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8822 template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8823 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getDescriptorSetLayoutSupport( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8824 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8825
8826 //=== VK_VERSION_1_2 ===
8827
8828
8829 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8830 VULKAN_HPP_NODISCARD Result createRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::RenderPass * pRenderPass, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8831 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8832 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8833 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::RenderPass>::type createRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8834 # ifndef VULKAN_HPP_NO_SMART_HANDLE
8835 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8836 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>>::type createRenderPass2Unique( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8837 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
8838 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8839
8840
8841 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8842 void resetQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8843
8844
8845 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8846 VULKAN_HPP_NODISCARD Result getSemaphoreCounterValue( VULKAN_HPP_NAMESPACE::Semaphore semaphore, uint64_t * pValue, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8847 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8848 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8849 VULKAN_HPP_NODISCARD typename ResultValueType<uint64_t>::type getSemaphoreCounterValue( VULKAN_HPP_NAMESPACE::Semaphore semaphore, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8850 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8851
8852
8853 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8854 VULKAN_HPP_NODISCARD Result waitSemaphores( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo * pWaitInfo, uint64_t timeout, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8855 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8856 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8857 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result waitSemaphores( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo & waitInfo, uint64_t timeout, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8858 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8859
8860
8861 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8862 VULKAN_HPP_NODISCARD Result signalSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo * pSignalInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8863 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8864 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8865 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type signalSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo & signalInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8866 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8867
8868
8869 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8870 DeviceAddress getBufferAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8871 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8872 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8873 VULKAN_HPP_NAMESPACE::DeviceAddress getBufferAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8874 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8875
8876
8877 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8878 uint64_t getBufferOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8879 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8880 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8881 uint64_t getBufferOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8882 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8883
8884
8885 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8886 uint64_t getMemoryOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo * pInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8887 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8888 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8889 uint64_t getMemoryOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8890 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8891
8892 //=== VK_VERSION_1_3 ===
8893
8894
8895 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8896 VULKAN_HPP_NODISCARD Result createPrivateDataSlot( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::PrivateDataSlot * pPrivateDataSlot, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8897 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8898 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8899 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::PrivateDataSlot>::type createPrivateDataSlot( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8900 # ifndef VULKAN_HPP_NO_SMART_HANDLE
8901 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8902 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PrivateDataSlot, Dispatch>>::type createPrivateDataSlotUnique( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8903 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
8904 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8905
8906
8907 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8908 void destroyPrivateDataSlot( VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8909 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8910 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8911 void destroyPrivateDataSlot( VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8912 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8913
8914
8915 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8916 void destroy( VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8917 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8918 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8919 void destroy( VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8920 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8921
8922
8923 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
8924 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8925 VULKAN_HPP_NODISCARD Result setPrivateData( VULKAN_HPP_NAMESPACE::ObjectType objectType_, uint64_t objectHandle, VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, uint64_t data, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8926 #else
8927 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8928 typename ResultValueType<void>::type setPrivateData( VULKAN_HPP_NAMESPACE::ObjectType objectType_, uint64_t objectHandle, VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, uint64_t data, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8929 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8930
8931
8932 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8933 void getPrivateData( VULKAN_HPP_NAMESPACE::ObjectType objectType_, uint64_t objectHandle, VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, uint64_t * pData, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8934 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8935 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8936 VULKAN_HPP_NODISCARD uint64_t getPrivateData( VULKAN_HPP_NAMESPACE::ObjectType objectType_, uint64_t objectHandle, VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8937 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8938
8939
8940 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8941 void getBufferMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements * pInfo, VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8942 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8943 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8944 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getBufferMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8945 template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8946 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getBufferMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8947 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8948
8949
8950 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8951 void getImageMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements * pInfo, VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8952 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8953 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8954 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getImageMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8955 template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8956 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getImageMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8957 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8958
8959
8960 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8961 void getImageSparseMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements * pInfo, uint32_t * pSparseMemoryRequirementCount, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 * pSparseMemoryRequirements, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8962 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8963 template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8964 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> getImageSparseMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8965 template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = SparseImageMemoryRequirements2Allocator, typename std::enable_if<std::is_same<typename B1::value_type, SparseImageMemoryRequirements2>::value, int>::type = 0>
8966 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> getImageSparseMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info, SparseImageMemoryRequirements2Allocator & sparseImageMemoryRequirements2Allocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8967 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8968
8969 //=== VK_KHR_swapchain ===
8970
8971
8972 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8973 VULKAN_HPP_NODISCARD Result createSwapchainKHR( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::SwapchainKHR * pSwapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8974 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8975 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8976 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SwapchainKHR>::type createSwapchainKHR( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8977 # ifndef VULKAN_HPP_NO_SMART_HANDLE
8978 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8979 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>>::type createSwapchainKHRUnique( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8980 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
8981 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8982
8983
8984 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8985 void destroySwapchainKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8986 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8987 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8988 void destroySwapchainKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8989 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8990
8991
8992 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8993 void destroy( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8994 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8995 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8996 void destroy( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8997 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8998
8999
9000 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9001 VULKAN_HPP_NODISCARD Result getSwapchainImagesKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, uint32_t * pSwapchainImageCount, VULKAN_HPP_NAMESPACE::Image * pSwapchainImages, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9002 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9003 template <typename ImageAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Image>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9004 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::Image, ImageAllocator>>::type getSwapchainImagesKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9005 template <typename ImageAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Image>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = ImageAllocator, typename std::enable_if<std::is_same<typename B1::value_type, Image>::value, int>::type = 0>
9006 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::Image, ImageAllocator>>::type getSwapchainImagesKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, ImageAllocator & imageAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9007 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9008
9009
9010 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9011 VULKAN_HPP_NODISCARD Result acquireNextImageKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, uint64_t timeout, VULKAN_HPP_NAMESPACE::Semaphore semaphore, VULKAN_HPP_NAMESPACE::Fence fence, uint32_t * pImageIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9012 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9013 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9014 VULKAN_HPP_NODISCARD ResultValue<uint32_t> acquireNextImageKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, uint64_t timeout, VULKAN_HPP_NAMESPACE::Semaphore semaphore VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9015 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9016
9017
9018 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9019 VULKAN_HPP_NODISCARD Result getGroupPresentCapabilitiesKHR( VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR * pDeviceGroupPresentCapabilities, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9020 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9021 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9022 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR>::type getGroupPresentCapabilitiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9023 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9024
9025
9026 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9027 VULKAN_HPP_NODISCARD Result getGroupSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR * pModes, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9028 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9029 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9030 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR>::type getGroupSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9031 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9032
9033
9034 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9035 VULKAN_HPP_NODISCARD Result acquireNextImage2KHR( const VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR * pAcquireInfo, uint32_t * pImageIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9036 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9037 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9038 VULKAN_HPP_NODISCARD ResultValue<uint32_t> acquireNextImage2KHR( const VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR & acquireInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9039 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9040
9041 //=== VK_KHR_display_swapchain ===
9042
9043
9044 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9045 VULKAN_HPP_NODISCARD Result createSharedSwapchainsKHR( uint32_t swapchainCount, const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR * pCreateInfos, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::SwapchainKHR * pSwapchains, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9046 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9047 template <typename SwapchainKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SwapchainKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9048 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SwapchainKHR, SwapchainKHRAllocator>>::type createSharedSwapchainsKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9049 template <typename SwapchainKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SwapchainKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B0 = SwapchainKHRAllocator, typename std::enable_if<std::is_same<typename B0::value_type, SwapchainKHR>::value, int>::type = 0>
9050 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SwapchainKHR, SwapchainKHRAllocator>>::type createSharedSwapchainsKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, SwapchainKHRAllocator & swapchainKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9051 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9052 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SwapchainKHR>::type createSharedSwapchainKHR( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9053 # ifndef VULKAN_HPP_NO_SMART_HANDLE
9054 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename SwapchainKHRAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>>>
9055 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>, SwapchainKHRAllocator>>::type createSharedSwapchainsKHRUnique( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9056 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename SwapchainKHRAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>>, typename B0 = SwapchainKHRAllocator, typename std::enable_if<std::is_same<typename B0::value_type, UniqueHandle<SwapchainKHR, Dispatch>>::value, int>::type = 0>
9057 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>, SwapchainKHRAllocator>>::type createSharedSwapchainsKHRUnique( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, SwapchainKHRAllocator & swapchainKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9058 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9059 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>>::type createSharedSwapchainKHRUnique( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9060 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
9061 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9062
9063 //=== VK_EXT_debug_marker ===
9064
9065
9066 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9067 VULKAN_HPP_NODISCARD Result debugMarkerSetObjectTagEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT * pTagInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9068 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9069 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9070 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type debugMarkerSetObjectTagEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT & tagInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9071 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9072
9073
9074 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9075 VULKAN_HPP_NODISCARD Result debugMarkerSetObjectNameEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT * pNameInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9076 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9077 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9078 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type debugMarkerSetObjectNameEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT & nameInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9079 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9080
9081 //=== VK_KHR_video_queue ===
9082
9083
9084 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9085 VULKAN_HPP_NODISCARD Result createVideoSessionKHR( const VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::VideoSessionKHR * pVideoSession, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9086 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9087 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9088 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::VideoSessionKHR>::type createVideoSessionKHR( const VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9089 # ifndef VULKAN_HPP_NO_SMART_HANDLE
9090 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9091 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::VideoSessionKHR, Dispatch>>::type createVideoSessionKHRUnique( const VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9092 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
9093 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9094
9095
9096 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9097 void destroyVideoSessionKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9098 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9099 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9100 void destroyVideoSessionKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9101 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9102
9103
9104 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9105 void destroy( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9106 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9107 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9108 void destroy( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9109 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9110
9111
9112 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9113 VULKAN_HPP_NODISCARD Result getVideoSessionMemoryRequirementsKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession, uint32_t * pMemoryRequirementsCount, VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR * pMemoryRequirements, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9114 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9115 template <typename VideoSessionMemoryRequirementsKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9116 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR, VideoSessionMemoryRequirementsKHRAllocator>>::type getVideoSessionMemoryRequirementsKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9117 template <typename VideoSessionMemoryRequirementsKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = VideoSessionMemoryRequirementsKHRAllocator, typename std::enable_if<std::is_same<typename B1::value_type, VideoSessionMemoryRequirementsKHR>::value, int>::type = 0>
9118 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR, VideoSessionMemoryRequirementsKHRAllocator>>::type getVideoSessionMemoryRequirementsKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession, VideoSessionMemoryRequirementsKHRAllocator & videoSessionMemoryRequirementsKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9119 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9120
9121
9122 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9123 VULKAN_HPP_NODISCARD Result bindVideoSessionMemoryKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession, uint32_t bindSessionMemoryInfoCount, const VULKAN_HPP_NAMESPACE::BindVideoSessionMemoryInfoKHR * pBindSessionMemoryInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9124 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9125 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9126 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type bindVideoSessionMemoryKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindVideoSessionMemoryInfoKHR> const & bindSessionMemoryInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9127 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9128
9129
9130 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9131 VULKAN_HPP_NODISCARD Result createVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR * pVideoSessionParameters, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9132 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9133 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9134 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR>::type createVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9135 # ifndef VULKAN_HPP_NO_SMART_HANDLE
9136 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9137 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR, Dispatch>>::type createVideoSessionParametersKHRUnique( const VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9138 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
9139 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9140
9141
9142 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9143 VULKAN_HPP_NODISCARD Result updateVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters, const VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR * pUpdateInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9144 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9145 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9146 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type updateVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters, const VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR & updateInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9147 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9148
9149
9150 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9151 void destroyVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9152 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9153 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9154 void destroyVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9155 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9156
9157
9158 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9159 void destroy( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9160 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9161 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9162 void destroy( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9163 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9164
9165 //=== VK_NVX_binary_import ===
9166
9167
9168 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9169 VULKAN_HPP_NODISCARD Result createCuModuleNVX( const VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::CuModuleNVX * pModule, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9170 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9171 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9172 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::CuModuleNVX>::type createCuModuleNVX( const VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9173 # ifndef VULKAN_HPP_NO_SMART_HANDLE
9174 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9175 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CuModuleNVX, Dispatch>>::type createCuModuleNVXUnique( const VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9176 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
9177 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9178
9179
9180 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9181 VULKAN_HPP_NODISCARD Result createCuFunctionNVX( const VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::CuFunctionNVX * pFunction, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9182 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9183 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9184 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::CuFunctionNVX>::type createCuFunctionNVX( const VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9185 # ifndef VULKAN_HPP_NO_SMART_HANDLE
9186 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9187 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CuFunctionNVX, Dispatch>>::type createCuFunctionNVXUnique( const VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9188 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
9189 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9190
9191
9192 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9193 void destroyCuModuleNVX( VULKAN_HPP_NAMESPACE::CuModuleNVX module, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9194 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9195 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9196 void destroyCuModuleNVX( VULKAN_HPP_NAMESPACE::CuModuleNVX module, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9197 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9198
9199
9200 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9201 void destroy( VULKAN_HPP_NAMESPACE::CuModuleNVX module, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9202 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9203 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9204 void destroy( VULKAN_HPP_NAMESPACE::CuModuleNVX module, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9205 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9206
9207
9208 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9209 void destroyCuFunctionNVX( VULKAN_HPP_NAMESPACE::CuFunctionNVX function, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9210 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9211 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9212 void destroyCuFunctionNVX( VULKAN_HPP_NAMESPACE::CuFunctionNVX function, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9213 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9214
9215
9216 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9217 void destroy( VULKAN_HPP_NAMESPACE::CuFunctionNVX function, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9218 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9219 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9220 void destroy( VULKAN_HPP_NAMESPACE::CuFunctionNVX function, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9221 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9222
9223 //=== VK_NVX_image_view_handle ===
9224
9225
9226 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9227 uint32_t getImageViewHandleNVX( const VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX * pInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9228 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9229 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9230 uint32_t getImageViewHandleNVX( const VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9231 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9232
9233
9234 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9235 VULKAN_HPP_NODISCARD Result getImageViewAddressNVX( VULKAN_HPP_NAMESPACE::ImageView imageView, VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX * pProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9236 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9237 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9238 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX>::type getImageViewAddressNVX( VULKAN_HPP_NAMESPACE::ImageView imageView, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9239 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9240
9241 //=== VK_AMD_shader_info ===
9242
9243
9244 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9245 VULKAN_HPP_NODISCARD Result getShaderInfoAMD( VULKAN_HPP_NAMESPACE::Pipeline pipeline, VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage, VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD infoType, size_t * pInfoSize, void * pInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9246 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9247 template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9248 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type getShaderInfoAMD( VULKAN_HPP_NAMESPACE::Pipeline pipeline, VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage, VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD infoType, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9249 template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = Uint8_tAllocator, typename std::enable_if<std::is_same<typename B1::value_type, uint8_t>::value, int>::type = 0>
9250 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type getShaderInfoAMD( VULKAN_HPP_NAMESPACE::Pipeline pipeline, VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage, VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD infoType, Uint8_tAllocator & uint8_tAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9251 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9252
9253 #if defined( VK_USE_PLATFORM_WIN32_KHR )
9254 //=== VK_NV_external_memory_win32 ===
9255
9256
9257 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9258 VULKAN_HPP_NODISCARD Result getMemoryWin32HandleNV( VULKAN_HPP_NAMESPACE::DeviceMemory memory, VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleType, HANDLE * pHandle, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9259 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9260 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9261 VULKAN_HPP_NODISCARD typename ResultValueType<HANDLE>::type getMemoryWin32HandleNV( VULKAN_HPP_NAMESPACE::DeviceMemory memory, VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleType, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9262 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9263 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
9264
9265 //=== VK_KHR_device_group ===
9266
9267
9268 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9269 void getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags * pPeerMemoryFeatures, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9270 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9271 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9272 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9273 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9274
9275 //=== VK_KHR_maintenance1 ===
9276
9277
9278 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9279 void trimCommandPoolKHR( VULKAN_HPP_NAMESPACE::CommandPool commandPool, VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9280
9281 #if defined( VK_USE_PLATFORM_WIN32_KHR )
9282 //=== VK_KHR_external_memory_win32 ===
9283
9284
9285 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9286 VULKAN_HPP_NODISCARD Result getMemoryWin32HandleKHR( const VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR * pGetWin32HandleInfo, HANDLE * pHandle, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9287 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9288 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9289 VULKAN_HPP_NODISCARD typename ResultValueType<HANDLE>::type getMemoryWin32HandleKHR( const VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9290 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9291
9292
9293 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9294 VULKAN_HPP_NODISCARD Result getMemoryWin32HandlePropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR * pMemoryWin32HandleProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9295 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9296 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9297 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR>::type getMemoryWin32HandlePropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9298 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9299 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
9300
9301 //=== VK_KHR_external_memory_fd ===
9302
9303
9304 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9305 VULKAN_HPP_NODISCARD Result getMemoryFdKHR( const VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR * pGetFdInfo, int * pFd, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9306 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9307 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9308 VULKAN_HPP_NODISCARD typename ResultValueType<int>::type getMemoryFdKHR( const VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR & getFdInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9309 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9310
9311
9312 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9313 VULKAN_HPP_NODISCARD Result getMemoryFdPropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, int fd, VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR * pMemoryFdProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9314 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9315 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9316 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR>::type getMemoryFdPropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, int fd, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9317 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9318
9319 #if defined( VK_USE_PLATFORM_WIN32_KHR )
9320 //=== VK_KHR_external_semaphore_win32 ===
9321
9322
9323 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9324 VULKAN_HPP_NODISCARD Result importSemaphoreWin32HandleKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR * pImportSemaphoreWin32HandleInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9325 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9326 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9327 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type importSemaphoreWin32HandleKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9328 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9329
9330
9331 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9332 VULKAN_HPP_NODISCARD Result getSemaphoreWin32HandleKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR * pGetWin32HandleInfo, HANDLE * pHandle, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9333 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9334 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9335 VULKAN_HPP_NODISCARD typename ResultValueType<HANDLE>::type getSemaphoreWin32HandleKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9336 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9337 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
9338
9339 //=== VK_KHR_external_semaphore_fd ===
9340
9341
9342 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9343 VULKAN_HPP_NODISCARD Result importSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR * pImportSemaphoreFdInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9344 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9345 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9346 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type importSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR & importSemaphoreFdInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9347 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9348
9349
9350 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9351 VULKAN_HPP_NODISCARD Result getSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR * pGetFdInfo, int * pFd, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9352 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9353 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9354 VULKAN_HPP_NODISCARD typename ResultValueType<int>::type getSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR & getFdInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9355 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9356
9357 //=== VK_KHR_descriptor_update_template ===
9358
9359
9360 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9361 VULKAN_HPP_NODISCARD Result createDescriptorUpdateTemplateKHR( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate * pDescriptorUpdateTemplate, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9362 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9363 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9364 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate>::type createDescriptorUpdateTemplateKHR( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9365 # ifndef VULKAN_HPP_NO_SMART_HANDLE
9366 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9367 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate, Dispatch>>::type createDescriptorUpdateTemplateKHRUnique( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9368 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
9369 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9370
9371
9372 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9373 void destroyDescriptorUpdateTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9374 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9375 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9376 void destroyDescriptorUpdateTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9377 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9378
9379
9380 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9381 void updateDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet, VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, const void * pData, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9382 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9383 template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9384 void updateDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet, VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, DataType const & data, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9385 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9386
9387 //=== VK_EXT_display_control ===
9388
9389
9390 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9391 VULKAN_HPP_NODISCARD Result displayPowerControlEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, const VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT * pDisplayPowerInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9392 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9393 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9394 typename ResultValueType<void>::type displayPowerControlEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, const VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT & displayPowerInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9395 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9396
9397
9398 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9399 VULKAN_HPP_NODISCARD Result registerEventEXT( const VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT * pDeviceEventInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::Fence * pFence, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9400 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9401 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9402 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Fence>::type registerEventEXT( const VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT & deviceEventInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9403 # ifndef VULKAN_HPP_NO_SMART_HANDLE
9404 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9405 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>>::type registerEventEXTUnique( const VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT & deviceEventInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9406 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
9407 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9408
9409
9410 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9411 VULKAN_HPP_NODISCARD Result registerDisplayEventEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, const VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT * pDisplayEventInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::Fence * pFence, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9412 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9413 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9414 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Fence>::type registerDisplayEventEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, const VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT & displayEventInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9415 # ifndef VULKAN_HPP_NO_SMART_HANDLE
9416 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9417 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>>::type registerDisplayEventEXTUnique( VULKAN_HPP_NAMESPACE::DisplayKHR display, const VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT & displayEventInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9418 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
9419 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9420
9421
9422 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9423 VULKAN_HPP_NODISCARD Result getSwapchainCounterEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, VULKAN_HPP_NAMESPACE::SurfaceCounterFlagBitsEXT counter, uint64_t * pCounterValue, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9424 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9425 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9426 VULKAN_HPP_NODISCARD typename ResultValueType<uint64_t>::type getSwapchainCounterEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, VULKAN_HPP_NAMESPACE::SurfaceCounterFlagBitsEXT counter, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9427 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9428
9429 //=== VK_GOOGLE_display_timing ===
9430
9431
9432 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9433 VULKAN_HPP_NODISCARD Result getRefreshCycleDurationGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE * pDisplayTimingProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9434 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9435 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9436 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE>::type getRefreshCycleDurationGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9437 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9438
9439
9440 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9441 VULKAN_HPP_NODISCARD Result getPastPresentationTimingGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, uint32_t * pPresentationTimingCount, VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE * pPresentationTimings, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9442 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9443 template <typename PastPresentationTimingGOOGLEAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9444 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator>>::type getPastPresentationTimingGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9445 template <typename PastPresentationTimingGOOGLEAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = PastPresentationTimingGOOGLEAllocator, typename std::enable_if<std::is_same<typename B1::value_type, PastPresentationTimingGOOGLE>::value, int>::type = 0>
9446 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator>>::type getPastPresentationTimingGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, PastPresentationTimingGOOGLEAllocator & pastPresentationTimingGOOGLEAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9447 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9448
9449 //=== VK_EXT_hdr_metadata ===
9450
9451
9452 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9453 void setHdrMetadataEXT( uint32_t swapchainCount, const VULKAN_HPP_NAMESPACE::SwapchainKHR * pSwapchains, const VULKAN_HPP_NAMESPACE::HdrMetadataEXT * pMetadata, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9454 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9455 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9456 void setHdrMetadataEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainKHR> const & swapchains, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::HdrMetadataEXT> const & metadata, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
9457 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9458
9459 //=== VK_KHR_create_renderpass2 ===
9460
9461
9462 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9463 VULKAN_HPP_NODISCARD Result createRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::RenderPass * pRenderPass, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9464 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9465 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9466 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::RenderPass>::type createRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9467 # ifndef VULKAN_HPP_NO_SMART_HANDLE
9468 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9469 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>>::type createRenderPass2KHRUnique( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9470 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
9471 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9472
9473 //=== VK_KHR_shared_presentable_image ===
9474
9475
9476 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
9477 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9478 VULKAN_HPP_NODISCARD Result getSwapchainStatusKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9479 #else
9480 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9481 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result getSwapchainStatusKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9482 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9483
9484 #if defined( VK_USE_PLATFORM_WIN32_KHR )
9485 //=== VK_KHR_external_fence_win32 ===
9486
9487
9488 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9489 VULKAN_HPP_NODISCARD Result importFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR * pImportFenceWin32HandleInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9490 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9491 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9492 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type importFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9493 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9494
9495
9496 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9497 VULKAN_HPP_NODISCARD Result getFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR * pGetWin32HandleInfo, HANDLE * pHandle, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9498 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9499 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9500 VULKAN_HPP_NODISCARD typename ResultValueType<HANDLE>::type getFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9501 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9502 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
9503
9504 //=== VK_KHR_external_fence_fd ===
9505
9506
9507 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9508 VULKAN_HPP_NODISCARD Result importFenceFdKHR( const VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR * pImportFenceFdInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9509 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9510 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9511 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type importFenceFdKHR( const VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR & importFenceFdInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9512 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9513
9514
9515 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9516 VULKAN_HPP_NODISCARD Result getFenceFdKHR( const VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR * pGetFdInfo, int * pFd, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9517 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9518 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9519 VULKAN_HPP_NODISCARD typename ResultValueType<int>::type getFenceFdKHR( const VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR & getFdInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9520 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9521
9522 //=== VK_KHR_performance_query ===
9523
9524
9525 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9526 VULKAN_HPP_NODISCARD Result acquireProfilingLockKHR( const VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR * pInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9527 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9528 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9529 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type acquireProfilingLockKHR( const VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9530 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9531
9532
9533 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9534 void releaseProfilingLockKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9535
9536 //=== VK_EXT_debug_utils ===
9537
9538
9539 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9540 VULKAN_HPP_NODISCARD Result setDebugUtilsObjectNameEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT * pNameInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9541 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9542 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9543 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type setDebugUtilsObjectNameEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT & nameInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9544 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9545
9546
9547 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9548 VULKAN_HPP_NODISCARD Result setDebugUtilsObjectTagEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT * pTagInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9549 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9550 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9551 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type setDebugUtilsObjectTagEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT & tagInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9552 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9553
9554 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
9555 //=== VK_ANDROID_external_memory_android_hardware_buffer ===
9556
9557
9558 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9559 VULKAN_HPP_NODISCARD Result getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer * buffer, VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID * pProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9560 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9561 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9562 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID>::type getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9563 template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9564 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>>::type getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9565 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9566
9567
9568 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9569 VULKAN_HPP_NODISCARD Result getMemoryAndroidHardwareBufferANDROID( const VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID * pInfo, struct AHardwareBuffer ** pBuffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9570 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9571 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9572 VULKAN_HPP_NODISCARD typename ResultValueType<struct AHardwareBuffer *>::type getMemoryAndroidHardwareBufferANDROID( const VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9573 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9574 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
9575
9576 #if defined( VK_ENABLE_BETA_EXTENSIONS )
9577 //=== VK_AMDX_shader_enqueue ===
9578
9579
9580 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9581 VULKAN_HPP_NODISCARD Result createExecutionGraphPipelinesAMDX( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, uint32_t createInfoCount, const VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX * pCreateInfos, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::Pipeline * pPipelines, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9582 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9583 template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9584 VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>> createExecutionGraphPipelinesAMDX( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9585 template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B0 = PipelineAllocator, typename std::enable_if<std::is_same<typename B0::value_type, Pipeline>::value, int>::type = 0>
9586 VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>> createExecutionGraphPipelinesAMDX( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, PipelineAllocator & pipelineAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9587 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9588 VULKAN_HPP_NODISCARD ResultValue<VULKAN_HPP_NAMESPACE::Pipeline> createExecutionGraphPipelineAMDX( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, const VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9589 # ifndef VULKAN_HPP_NO_SMART_HANDLE
9590 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>>
9591 VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>> createExecutionGraphPipelinesAMDXUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9592 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>, typename B0 = PipelineAllocator, typename std::enable_if<std::is_same<typename B0::value_type, UniqueHandle<Pipeline, Dispatch>>::value, int>::type = 0>
9593 VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>> createExecutionGraphPipelinesAMDXUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, PipelineAllocator & pipelineAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9594 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9595 VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>> createExecutionGraphPipelineAMDXUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, const VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9596 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
9597 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9598
9599
9600 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9601 VULKAN_HPP_NODISCARD Result getExecutionGraphPipelineScratchSizeAMDX( VULKAN_HPP_NAMESPACE::Pipeline executionGraph, VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineScratchSizeAMDX * pSizeInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9602 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9603 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9604 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineScratchSizeAMDX>::type getExecutionGraphPipelineScratchSizeAMDX( VULKAN_HPP_NAMESPACE::Pipeline executionGraph, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9605 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9606
9607
9608 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9609 VULKAN_HPP_NODISCARD Result getExecutionGraphPipelineNodeIndexAMDX( VULKAN_HPP_NAMESPACE::Pipeline executionGraph, const VULKAN_HPP_NAMESPACE::PipelineShaderStageNodeCreateInfoAMDX * pNodeInfo, uint32_t * pNodeIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9610 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9611 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9612 VULKAN_HPP_NODISCARD typename ResultValueType<uint32_t>::type getExecutionGraphPipelineNodeIndexAMDX( VULKAN_HPP_NAMESPACE::Pipeline executionGraph, const VULKAN_HPP_NAMESPACE::PipelineShaderStageNodeCreateInfoAMDX & nodeInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9613 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9614 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
9615
9616 //=== VK_KHR_get_memory_requirements2 ===
9617
9618
9619 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9620 void getImageMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 * pInfo, VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9621 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9622 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9623 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getImageMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9624 template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9625 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getImageMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9626 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9627
9628
9629 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9630 void getBufferMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 * pInfo, VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9631 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9632 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9633 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getBufferMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9634 template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9635 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getBufferMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9636 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9637
9638
9639 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9640 void getImageSparseMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 * pInfo, uint32_t * pSparseMemoryRequirementCount, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 * pSparseMemoryRequirements, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9641 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9642 template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9643 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> getImageSparseMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9644 template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = SparseImageMemoryRequirements2Allocator, typename std::enable_if<std::is_same<typename B1::value_type, SparseImageMemoryRequirements2>::value, int>::type = 0>
9645 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> getImageSparseMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info, SparseImageMemoryRequirements2Allocator & sparseImageMemoryRequirements2Allocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9646 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9647
9648 //=== VK_KHR_acceleration_structure ===
9649
9650
9651 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9652 VULKAN_HPP_NODISCARD Result createAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::AccelerationStructureKHR * pAccelerationStructure, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9653 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9654 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9655 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR>::type createAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9656 # ifndef VULKAN_HPP_NO_SMART_HANDLE
9657 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9658 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR, Dispatch>>::type createAccelerationStructureKHRUnique( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9659 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
9660 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9661
9662
9663 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9664 void destroyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9665 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9666 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9667 void destroyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9668 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9669
9670
9671 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9672 void destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9673 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9674 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9675 void destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9676 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9677
9678
9679 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9680 VULKAN_HPP_NODISCARD Result buildAccelerationStructuresKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, uint32_t infoCount, const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR * pInfos, const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9681 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9682 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9683 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result buildAccelerationStructuresKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const> const & pBuildRangeInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9684 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9685
9686
9687 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9688 VULKAN_HPP_NODISCARD Result copyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR * pInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9689 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9690 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9691 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result copyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9692 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9693
9694
9695 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9696 VULKAN_HPP_NODISCARD Result copyAccelerationStructureToMemoryKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR * pInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9697 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9698 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9699 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result copyAccelerationStructureToMemoryKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9700 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9701
9702
9703 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9704 VULKAN_HPP_NODISCARD Result copyMemoryToAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR * pInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9705 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9706 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9707 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result copyMemoryToAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9708 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9709
9710
9711 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9712 VULKAN_HPP_NODISCARD Result writeAccelerationStructuresPropertiesKHR( uint32_t accelerationStructureCount, const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR * pAccelerationStructures, VULKAN_HPP_NAMESPACE::QueryType queryType, size_t dataSize, void * pData, size_t stride, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9713 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9714 template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9715 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type writeAccelerationStructuresPropertiesKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures, VULKAN_HPP_NAMESPACE::QueryType queryType, size_t dataSize, size_t stride, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9716 template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9717 VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type writeAccelerationStructuresPropertyKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures, VULKAN_HPP_NAMESPACE::QueryType queryType, size_t stride, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9718 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9719
9720
9721 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9722 DeviceAddress getAccelerationStructureAddressKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR * pInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9723 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9724 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9725 VULKAN_HPP_NAMESPACE::DeviceAddress getAccelerationStructureAddressKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9726 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9727
9728
9729 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9730 void getAccelerationStructureCompatibilityKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR * pVersionInfo, VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR * pCompatibility, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9731 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9732 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9733 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR getAccelerationStructureCompatibilityKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR & versionInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9734 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9735
9736
9737 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9738 void getAccelerationStructureBuildSizesKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR buildType, const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR * pBuildInfo, const uint32_t * pMaxPrimitiveCounts, VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR * pSizeInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9739 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9740 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9741 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR getAccelerationStructureBuildSizesKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR buildType, const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR & buildInfo, VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t> const & maxPrimitiveCounts VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
9742 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9743
9744 //=== VK_KHR_ray_tracing_pipeline ===
9745
9746
9747 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9748 VULKAN_HPP_NODISCARD Result createRayTracingPipelinesKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, uint32_t createInfoCount, const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR * pCreateInfos, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::Pipeline * pPipelines, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9749 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9750 template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9751 VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>> createRayTracingPipelinesKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9752 template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B0 = PipelineAllocator, typename std::enable_if<std::is_same<typename B0::value_type, Pipeline>::value, int>::type = 0>
9753 VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>> createRayTracingPipelinesKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, PipelineAllocator & pipelineAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9754 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9755 VULKAN_HPP_NODISCARD ResultValue<VULKAN_HPP_NAMESPACE::Pipeline> createRayTracingPipelineKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9756 # ifndef VULKAN_HPP_NO_SMART_HANDLE
9757 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>>
9758 VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>> createRayTracingPipelinesKHRUnique( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9759 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>, typename B0 = PipelineAllocator, typename std::enable_if<std::is_same<typename B0::value_type, UniqueHandle<Pipeline, Dispatch>>::value, int>::type = 0>
9760 VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>> createRayTracingPipelinesKHRUnique( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, PipelineAllocator & pipelineAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9761 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9762 VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>> createRayTracingPipelineKHRUnique( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9763 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
9764 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9765
9766
9767 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9768 VULKAN_HPP_NODISCARD Result getRayTracingShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void * pData, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9769 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9770 template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9771 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type getRayTracingShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9772 template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9773 VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type getRayTracingShaderGroupHandleKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9774 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9775
9776
9777 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9778 VULKAN_HPP_NODISCARD Result getRayTracingCaptureReplayShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void * pData, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9779 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9780 template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9781 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type getRayTracingCaptureReplayShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9782 template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9783 VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type getRayTracingCaptureReplayShaderGroupHandleKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9784 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9785
9786
9787 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9788 DeviceSize getRayTracingShaderGroupStackSizeKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t group, VULKAN_HPP_NAMESPACE::ShaderGroupShaderKHR groupShader, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9789
9790 //=== VK_KHR_sampler_ycbcr_conversion ===
9791
9792
9793 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9794 VULKAN_HPP_NODISCARD Result createSamplerYcbcrConversionKHR( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion * pYcbcrConversion, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9795 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9796 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9797 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>::type createSamplerYcbcrConversionKHR( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9798 # ifndef VULKAN_HPP_NO_SMART_HANDLE
9799 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9800 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion, Dispatch>>::type createSamplerYcbcrConversionKHRUnique( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9801 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
9802 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9803
9804
9805 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9806 void destroySamplerYcbcrConversionKHR( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9807 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9808 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9809 void destroySamplerYcbcrConversionKHR( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9810 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9811
9812 //=== VK_KHR_bind_memory2 ===
9813
9814
9815 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9816 VULKAN_HPP_NODISCARD Result bindBufferMemory2KHR( uint32_t bindInfoCount, const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo * pBindInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9817 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9818 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9819 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type bindBufferMemory2KHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const & bindInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9820 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9821
9822
9823 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9824 VULKAN_HPP_NODISCARD Result bindImageMemory2KHR( uint32_t bindInfoCount, const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo * pBindInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9825 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9826 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9827 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type bindImageMemory2KHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const & bindInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9828 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9829
9830 //=== VK_EXT_image_drm_format_modifier ===
9831
9832
9833 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9834 VULKAN_HPP_NODISCARD Result getImageDrmFormatModifierPropertiesEXT( VULKAN_HPP_NAMESPACE::Image image, VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT * pProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9835 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9836 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9837 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT>::type getImageDrmFormatModifierPropertiesEXT( VULKAN_HPP_NAMESPACE::Image image, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9838 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9839
9840 //=== VK_EXT_validation_cache ===
9841
9842
9843 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9844 VULKAN_HPP_NODISCARD Result createValidationCacheEXT( const VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::ValidationCacheEXT * pValidationCache, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9845 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9846 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9847 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ValidationCacheEXT>::type createValidationCacheEXT( const VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9848 # ifndef VULKAN_HPP_NO_SMART_HANDLE
9849 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9850 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ValidationCacheEXT, Dispatch>>::type createValidationCacheEXTUnique( const VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9851 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
9852 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9853
9854
9855 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9856 void destroyValidationCacheEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9857 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9858 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9859 void destroyValidationCacheEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9860 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9861
9862
9863 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9864 void destroy( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9865 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9866 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9867 void destroy( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9868 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9869
9870
9871 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9872 VULKAN_HPP_NODISCARD Result mergeValidationCachesEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT dstCache, uint32_t srcCacheCount, const VULKAN_HPP_NAMESPACE::ValidationCacheEXT * pSrcCaches, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9873 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9874 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9875 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type mergeValidationCachesEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT dstCache, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ValidationCacheEXT> const & srcCaches, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9876 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9877
9878
9879 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9880 VULKAN_HPP_NODISCARD Result getValidationCacheDataEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache, size_t * pDataSize, void * pData, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9881 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9882 template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9883 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type getValidationCacheDataEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9884 template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = Uint8_tAllocator, typename std::enable_if<std::is_same<typename B1::value_type, uint8_t>::value, int>::type = 0>
9885 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type getValidationCacheDataEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache, Uint8_tAllocator & uint8_tAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9886 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9887
9888 //=== VK_NV_ray_tracing ===
9889
9890
9891 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9892 VULKAN_HPP_NODISCARD Result createAccelerationStructureNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::AccelerationStructureNV * pAccelerationStructure, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9893 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9894 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9895 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::AccelerationStructureNV>::type createAccelerationStructureNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9896 # ifndef VULKAN_HPP_NO_SMART_HANDLE
9897 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9898 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::AccelerationStructureNV, Dispatch>>::type createAccelerationStructureNVUnique( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9899 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
9900 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9901
9902
9903 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9904 void destroyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9905 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9906 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9907 void destroyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9908 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9909
9910
9911 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9912 void destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9913 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9914 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9915 void destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9916 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9917
9918
9919 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9920 void getAccelerationStructureMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV * pInfo, VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR * pMemoryRequirements, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9921 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9922 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9923 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR getAccelerationStructureMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9924 template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9925 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getAccelerationStructureMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9926 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9927
9928
9929 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9930 VULKAN_HPP_NODISCARD Result bindAccelerationStructureMemoryNV( uint32_t bindInfoCount, const VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV * pBindInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9931 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9932 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9933 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type bindAccelerationStructureMemoryNV( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV> const & bindInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9934 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9935
9936
9937 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9938 VULKAN_HPP_NODISCARD Result createRayTracingPipelinesNV( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, uint32_t createInfoCount, const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV * pCreateInfos, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::Pipeline * pPipelines, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9939 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9940 template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9941 VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>> createRayTracingPipelinesNV( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9942 template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B0 = PipelineAllocator, typename std::enable_if<std::is_same<typename B0::value_type, Pipeline>::value, int>::type = 0>
9943 VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>> createRayTracingPipelinesNV( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, PipelineAllocator & pipelineAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9944 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9945 VULKAN_HPP_NODISCARD ResultValue<VULKAN_HPP_NAMESPACE::Pipeline> createRayTracingPipelineNV( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9946 # ifndef VULKAN_HPP_NO_SMART_HANDLE
9947 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>>
9948 VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>> createRayTracingPipelinesNVUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9949 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>, typename B0 = PipelineAllocator, typename std::enable_if<std::is_same<typename B0::value_type, UniqueHandle<Pipeline, Dispatch>>::value, int>::type = 0>
9950 VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>> createRayTracingPipelinesNVUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, PipelineAllocator & pipelineAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9951 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9952 VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>> createRayTracingPipelineNVUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9953 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
9954 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9955
9956
9957 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9958 VULKAN_HPP_NODISCARD Result getRayTracingShaderGroupHandlesNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void * pData, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9959 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9960 template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9961 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type getRayTracingShaderGroupHandlesNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9962 template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9963 VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type getRayTracingShaderGroupHandleNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9964 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9965
9966
9967 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9968 VULKAN_HPP_NODISCARD Result getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure, size_t dataSize, void * pData, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9969 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9970 template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9971 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure, size_t dataSize, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9972 template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9973 VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9974 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9975
9976
9977 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
9978 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9979 VULKAN_HPP_NODISCARD Result compileDeferredNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t shader, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9980 #else
9981 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9982 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type compileDeferredNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t shader, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9983 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9984
9985 //=== VK_KHR_maintenance3 ===
9986
9987
9988 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9989 void getDescriptorSetLayoutSupportKHR( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo * pCreateInfo, VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport * pSupport, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9990 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9991 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9992 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport getDescriptorSetLayoutSupportKHR( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9993 template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9994 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getDescriptorSetLayoutSupportKHR( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9995 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9996
9997 //=== VK_EXT_external_memory_host ===
9998
9999
10000 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10001 VULKAN_HPP_NODISCARD Result getMemoryHostPointerPropertiesEXT( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, const void * pHostPointer, VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT * pMemoryHostPointerProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10002 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10003 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10004 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT>::type getMemoryHostPointerPropertiesEXT( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, const void * pHostPointer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10005 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10006
10007 //=== VK_EXT_calibrated_timestamps ===
10008
10009
10010 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10011 VULKAN_HPP_NODISCARD Result getCalibratedTimestampsEXT( uint32_t timestampCount, const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT * pTimestampInfos, uint64_t * pTimestamps, uint64_t * pMaxDeviation, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10012 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10013 template <typename Uint64_tAllocator = std::allocator<uint64_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10014 VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type getCalibratedTimestampsEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT> const & timestampInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10015 template <typename Uint64_tAllocator = std::allocator<uint64_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B0 = Uint64_tAllocator, typename std::enable_if<std::is_same<typename B0::value_type, uint64_t>::value, int>::type = 0>
10016 VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type getCalibratedTimestampsEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT> const & timestampInfos, Uint64_tAllocator & uint64_tAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10017 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10018 VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<uint64_t, uint64_t>>::type getCalibratedTimestampEXT( const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT & timestampInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10019 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10020
10021 //=== VK_KHR_timeline_semaphore ===
10022
10023
10024 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10025 VULKAN_HPP_NODISCARD Result getSemaphoreCounterValueKHR( VULKAN_HPP_NAMESPACE::Semaphore semaphore, uint64_t * pValue, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10026 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10027 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10028 VULKAN_HPP_NODISCARD typename ResultValueType<uint64_t>::type getSemaphoreCounterValueKHR( VULKAN_HPP_NAMESPACE::Semaphore semaphore, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10029 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10030
10031
10032 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10033 VULKAN_HPP_NODISCARD Result waitSemaphoresKHR( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo * pWaitInfo, uint64_t timeout, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10034 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10035 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10036 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result waitSemaphoresKHR( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo & waitInfo, uint64_t timeout, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10037 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10038
10039
10040 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10041 VULKAN_HPP_NODISCARD Result signalSemaphoreKHR( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo * pSignalInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10042 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10043 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10044 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type signalSemaphoreKHR( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo & signalInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10045 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10046
10047 //=== VK_INTEL_performance_query ===
10048
10049
10050 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10051 VULKAN_HPP_NODISCARD Result initializePerformanceApiINTEL( const VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL * pInitializeInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10052 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10053 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10054 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type initializePerformanceApiINTEL( const VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL & initializeInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10055 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10056
10057
10058 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10059 void uninitializePerformanceApiINTEL( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10060
10061
10062 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10063 VULKAN_HPP_NODISCARD Result acquirePerformanceConfigurationINTEL( const VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL * pAcquireInfo, VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL * pConfiguration, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10064 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10065 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10066 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL>::type acquirePerformanceConfigurationINTEL( const VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL & acquireInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10067 # ifndef VULKAN_HPP_NO_SMART_HANDLE
10068 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10069 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL, Dispatch>>::type acquirePerformanceConfigurationINTELUnique( const VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL & acquireInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10070 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
10071 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10072
10073
10074 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
10075 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10076 VULKAN_HPP_NODISCARD Result releasePerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10077 #else
10078 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10079 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type releasePerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10080 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10081
10082
10083 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
10084 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10085 VULKAN_HPP_NODISCARD Result release( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10086 #else
10087 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10088 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type release( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10089 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10090
10091
10092 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10093 VULKAN_HPP_NODISCARD Result getPerformanceParameterINTEL( VULKAN_HPP_NAMESPACE::PerformanceParameterTypeINTEL parameter, VULKAN_HPP_NAMESPACE::PerformanceValueINTEL * pValue, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10094 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10095 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10096 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::PerformanceValueINTEL>::type getPerformanceParameterINTEL( VULKAN_HPP_NAMESPACE::PerformanceParameterTypeINTEL parameter, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10097 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10098
10099 //=== VK_AMD_display_native_hdr ===
10100
10101
10102 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10103 void setLocalDimmingAMD( VULKAN_HPP_NAMESPACE::SwapchainKHR swapChain, VULKAN_HPP_NAMESPACE::Bool32 localDimmingEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10104
10105 //=== VK_EXT_buffer_device_address ===
10106
10107
10108 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10109 DeviceAddress getBufferAddressEXT( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10110 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10111 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10112 VULKAN_HPP_NAMESPACE::DeviceAddress getBufferAddressEXT( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10113 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10114
10115 //=== VK_KHR_present_wait ===
10116
10117
10118 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
10119 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10120 VULKAN_HPP_NODISCARD Result waitForPresentKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, uint64_t presentId, uint64_t timeout, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10121 #else
10122 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10123 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result waitForPresentKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, uint64_t presentId, uint64_t timeout, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10124 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10125
10126 #if defined( VK_USE_PLATFORM_WIN32_KHR )
10127 //=== VK_EXT_full_screen_exclusive ===
10128
10129
10130 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
10131 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10132 VULKAN_HPP_NODISCARD Result acquireFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10133 #else
10134 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10135 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type acquireFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10136 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10137
10138
10139 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
10140 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10141 VULKAN_HPP_NODISCARD Result releaseFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10142 #else
10143 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10144 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type releaseFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10145 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10146
10147
10148 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10149 VULKAN_HPP_NODISCARD Result getGroupSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo, VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR * pModes, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10150 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10151 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10152 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR>::type getGroupSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10153 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10154 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
10155
10156 //=== VK_KHR_buffer_device_address ===
10157
10158
10159 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10160 DeviceAddress getBufferAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10161 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10162 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10163 VULKAN_HPP_NAMESPACE::DeviceAddress getBufferAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10164 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10165
10166
10167 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10168 uint64_t getBufferOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10169 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10170 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10171 uint64_t getBufferOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10172 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10173
10174
10175 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10176 uint64_t getMemoryOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo * pInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10177 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10178 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10179 uint64_t getMemoryOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10180 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10181
10182 //=== VK_EXT_host_query_reset ===
10183
10184
10185 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10186 void resetQueryPoolEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10187
10188 //=== VK_KHR_deferred_host_operations ===
10189
10190
10191 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10192 VULKAN_HPP_NODISCARD Result createDeferredOperationKHR( const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::DeferredOperationKHR * pDeferredOperation, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10193 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10194 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10195 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DeferredOperationKHR>::type createDeferredOperationKHR( Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10196 # ifndef VULKAN_HPP_NO_SMART_HANDLE
10197 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10198 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DeferredOperationKHR, Dispatch>>::type createDeferredOperationKHRUnique( Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10199 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
10200 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10201
10202
10203 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10204 void destroyDeferredOperationKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10205 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10206 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10207 void destroyDeferredOperationKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10208 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10209
10210
10211 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10212 void destroy( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10213 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10214 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10215 void destroy( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10216 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10217
10218
10219 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10220 uint32_t getDeferredOperationMaxConcurrencyKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10221
10222
10223 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
10224 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10225 VULKAN_HPP_NODISCARD Result getDeferredOperationResultKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10226 #else
10227 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10228 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result getDeferredOperationResultKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10229 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10230
10231
10232 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
10233 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10234 VULKAN_HPP_NODISCARD Result deferredOperationJoinKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10235 #else
10236 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10237 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result deferredOperationJoinKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10238 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10239
10240 //=== VK_KHR_pipeline_executable_properties ===
10241
10242
10243 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10244 VULKAN_HPP_NODISCARD Result getPipelineExecutablePropertiesKHR( const VULKAN_HPP_NAMESPACE::PipelineInfoKHR * pPipelineInfo, uint32_t * pExecutableCount, VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR * pProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10245 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10246 template <typename PipelineExecutablePropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10247 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR, PipelineExecutablePropertiesKHRAllocator>>::type getPipelineExecutablePropertiesKHR( const VULKAN_HPP_NAMESPACE::PipelineInfoKHR & pipelineInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10248 template <typename PipelineExecutablePropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = PipelineExecutablePropertiesKHRAllocator, typename std::enable_if<std::is_same<typename B1::value_type, PipelineExecutablePropertiesKHR>::value, int>::type = 0>
10249 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR, PipelineExecutablePropertiesKHRAllocator>>::type getPipelineExecutablePropertiesKHR( const VULKAN_HPP_NAMESPACE::PipelineInfoKHR & pipelineInfo, PipelineExecutablePropertiesKHRAllocator & pipelineExecutablePropertiesKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10250 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10251
10252
10253 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10254 VULKAN_HPP_NODISCARD Result getPipelineExecutableStatisticsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR * pExecutableInfo, uint32_t * pStatisticCount, VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR * pStatistics, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10255 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10256 template <typename PipelineExecutableStatisticKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10257 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR, PipelineExecutableStatisticKHRAllocator>>::type getPipelineExecutableStatisticsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10258 template <typename PipelineExecutableStatisticKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = PipelineExecutableStatisticKHRAllocator, typename std::enable_if<std::is_same<typename B1::value_type, PipelineExecutableStatisticKHR>::value, int>::type = 0>
10259 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR, PipelineExecutableStatisticKHRAllocator>>::type getPipelineExecutableStatisticsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo, PipelineExecutableStatisticKHRAllocator & pipelineExecutableStatisticKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10260 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10261
10262
10263 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10264 VULKAN_HPP_NODISCARD Result getPipelineExecutableInternalRepresentationsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR * pExecutableInfo, uint32_t * pInternalRepresentationCount, VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR * pInternalRepresentations, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10265 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10266 template <typename PipelineExecutableInternalRepresentationKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10267 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR, PipelineExecutableInternalRepresentationKHRAllocator>>::type getPipelineExecutableInternalRepresentationsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10268 template <typename PipelineExecutableInternalRepresentationKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = PipelineExecutableInternalRepresentationKHRAllocator, typename std::enable_if<std::is_same<typename B1::value_type, PipelineExecutableInternalRepresentationKHR>::value, int>::type = 0>
10269 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR, PipelineExecutableInternalRepresentationKHRAllocator>>::type getPipelineExecutableInternalRepresentationsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo, PipelineExecutableInternalRepresentationKHRAllocator & pipelineExecutableInternalRepresentationKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10270 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10271
10272 //=== VK_EXT_host_image_copy ===
10273
10274
10275 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10276 VULKAN_HPP_NODISCARD Result copyMemoryToImageEXT( const VULKAN_HPP_NAMESPACE::CopyMemoryToImageInfoEXT * pCopyMemoryToImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10277 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10278 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10279 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type copyMemoryToImageEXT( const VULKAN_HPP_NAMESPACE::CopyMemoryToImageInfoEXT & copyMemoryToImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10280 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10281
10282
10283 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10284 VULKAN_HPP_NODISCARD Result copyImageToMemoryEXT( const VULKAN_HPP_NAMESPACE::CopyImageToMemoryInfoEXT * pCopyImageToMemoryInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10285 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10286 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10287 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type copyImageToMemoryEXT( const VULKAN_HPP_NAMESPACE::CopyImageToMemoryInfoEXT & copyImageToMemoryInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10288 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10289
10290
10291 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10292 VULKAN_HPP_NODISCARD Result copyImageToImageEXT( const VULKAN_HPP_NAMESPACE::CopyImageToImageInfoEXT * pCopyImageToImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10293 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10294 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10295 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type copyImageToImageEXT( const VULKAN_HPP_NAMESPACE::CopyImageToImageInfoEXT & copyImageToImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10296 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10297
10298
10299 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10300 VULKAN_HPP_NODISCARD Result transitionImageLayoutEXT( uint32_t transitionCount, const VULKAN_HPP_NAMESPACE::HostImageLayoutTransitionInfoEXT * pTransitions, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10301 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10302 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10303 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type transitionImageLayoutEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::HostImageLayoutTransitionInfoEXT> const & transitions, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10304 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10305
10306
10307 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10308 void getImageSubresourceLayout2EXT( VULKAN_HPP_NAMESPACE::Image image, const VULKAN_HPP_NAMESPACE::ImageSubresource2KHR * pSubresource, VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR * pLayout, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10309 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10310 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10311 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR getImageSubresourceLayout2EXT( VULKAN_HPP_NAMESPACE::Image image, const VULKAN_HPP_NAMESPACE::ImageSubresource2KHR & subresource, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10312 template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10313 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getImageSubresourceLayout2EXT( VULKAN_HPP_NAMESPACE::Image image, const VULKAN_HPP_NAMESPACE::ImageSubresource2KHR & subresource, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10314 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10315
10316 //=== VK_KHR_map_memory2 ===
10317
10318
10319 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10320 VULKAN_HPP_NODISCARD Result mapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryMapInfoKHR * pMemoryMapInfo, void ** ppData, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10321 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10322 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10323 VULKAN_HPP_NODISCARD typename ResultValueType<void *>::type mapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryMapInfoKHR & memoryMapInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10324 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10325
10326
10327 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10328 Result unmapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryUnmapInfoKHR * pMemoryUnmapInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10329 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10330 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10331 void unmapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryUnmapInfoKHR & memoryUnmapInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10332 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10333
10334 //=== VK_EXT_swapchain_maintenance1 ===
10335
10336
10337 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10338 VULKAN_HPP_NODISCARD Result releaseSwapchainImagesEXT( const VULKAN_HPP_NAMESPACE::ReleaseSwapchainImagesInfoEXT * pReleaseInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10339 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10340 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10341 typename ResultValueType<void>::type releaseSwapchainImagesEXT( const VULKAN_HPP_NAMESPACE::ReleaseSwapchainImagesInfoEXT & releaseInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10342 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10343
10344 //=== VK_NV_device_generated_commands ===
10345
10346
10347 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10348 void getGeneratedCommandsMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV * pInfo, VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10349 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10350 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10351 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getGeneratedCommandsMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10352 template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10353 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getGeneratedCommandsMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10354 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10355
10356
10357 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10358 VULKAN_HPP_NODISCARD Result createIndirectCommandsLayoutNV( const VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV * pIndirectCommandsLayout, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10359 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10360 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10361 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV>::type createIndirectCommandsLayoutNV( const VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10362 # ifndef VULKAN_HPP_NO_SMART_HANDLE
10363 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10364 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV, Dispatch>>::type createIndirectCommandsLayoutNVUnique( const VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10365 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
10366 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10367
10368
10369 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10370 void destroyIndirectCommandsLayoutNV( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10371 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10372 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10373 void destroyIndirectCommandsLayoutNV( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10374 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10375
10376
10377 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10378 void destroy( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10379 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10380 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10381 void destroy( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10382 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10383
10384 //=== VK_EXT_private_data ===
10385
10386
10387 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10388 VULKAN_HPP_NODISCARD Result createPrivateDataSlotEXT( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::PrivateDataSlot * pPrivateDataSlot, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10389 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10390 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10391 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::PrivateDataSlot>::type createPrivateDataSlotEXT( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10392 # ifndef VULKAN_HPP_NO_SMART_HANDLE
10393 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10394 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PrivateDataSlot, Dispatch>>::type createPrivateDataSlotEXTUnique( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10395 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
10396 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10397
10398
10399 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10400 void destroyPrivateDataSlotEXT( VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10401 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10402 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10403 void destroyPrivateDataSlotEXT( VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10404 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10405
10406
10407 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
10408 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10409 VULKAN_HPP_NODISCARD Result setPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType objectType_, uint64_t objectHandle, VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, uint64_t data, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10410 #else
10411 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10412 typename ResultValueType<void>::type setPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType objectType_, uint64_t objectHandle, VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, uint64_t data, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10413 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10414
10415
10416 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10417 void getPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType objectType_, uint64_t objectHandle, VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, uint64_t * pData, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10418 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10419 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10420 VULKAN_HPP_NODISCARD uint64_t getPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType objectType_, uint64_t objectHandle, VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10421 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10422
10423 #if defined( VK_ENABLE_BETA_EXTENSIONS )
10424 //=== VK_KHR_video_encode_queue ===
10425
10426
10427 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10428 VULKAN_HPP_NODISCARD Result getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR * pVideoSessionParametersInfo, VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR * pFeedbackInfo, size_t * pDataSize, void * pData, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10429 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10430 template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10431 VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR, std::vector<uint8_t, Uint8_tAllocator>>>::type getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10432 template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B2 = Uint8_tAllocator, typename std::enable_if<std::is_same<typename B2::value_type, uint8_t>::value, int>::type = 0>
10433 VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR, std::vector<uint8_t, Uint8_tAllocator>>>::type getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo, Uint8_tAllocator & uint8_tAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10434 template <typename X, typename Y, typename... Z, typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10435 VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>, std::vector<uint8_t, Uint8_tAllocator>>>::type getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10436 template <typename X, typename Y, typename... Z, typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B2 = Uint8_tAllocator, typename std::enable_if<std::is_same<typename B2::value_type, uint8_t>::value, int>::type = 0>
10437 VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>, std::vector<uint8_t, Uint8_tAllocator>>>::type getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo, Uint8_tAllocator & uint8_tAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10438 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10439 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
10440
10441 #if defined( VK_USE_PLATFORM_METAL_EXT )
10442 //=== VK_EXT_metal_objects ===
10443
10444
10445 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10446 void exportMetalObjectsEXT( VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT * pMetalObjectsInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10447 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10448 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10449 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT exportMetalObjectsEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10450 template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10451 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> exportMetalObjectsEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10452 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10453 #endif /*VK_USE_PLATFORM_METAL_EXT*/
10454
10455 //=== VK_EXT_descriptor_buffer ===
10456
10457
10458 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10459 void getDescriptorSetLayoutSizeEXT( VULKAN_HPP_NAMESPACE::DescriptorSetLayout layout, VULKAN_HPP_NAMESPACE::DeviceSize * pLayoutSizeInBytes, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10460 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10461 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10462 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceSize getDescriptorSetLayoutSizeEXT( VULKAN_HPP_NAMESPACE::DescriptorSetLayout layout, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10463 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10464
10465
10466 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10467 void getDescriptorSetLayoutBindingOffsetEXT( VULKAN_HPP_NAMESPACE::DescriptorSetLayout layout, uint32_t binding, VULKAN_HPP_NAMESPACE::DeviceSize * pOffset, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10468 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10469 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10470 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceSize getDescriptorSetLayoutBindingOffsetEXT( VULKAN_HPP_NAMESPACE::DescriptorSetLayout layout, uint32_t binding, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10471 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10472
10473
10474 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10475 void getDescriptorEXT( const VULKAN_HPP_NAMESPACE::DescriptorGetInfoEXT * pDescriptorInfo, size_t dataSize, void * pDescriptor, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10476 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10477 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10478 void getDescriptorEXT( const VULKAN_HPP_NAMESPACE::DescriptorGetInfoEXT & descriptorInfo, size_t dataSize, void * pDescriptor, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10479 template <typename DescriptorType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10480 VULKAN_HPP_NODISCARD DescriptorType getDescriptorEXT( const VULKAN_HPP_NAMESPACE::DescriptorGetInfoEXT & descriptorInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10481 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10482
10483
10484 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10485 VULKAN_HPP_NODISCARD Result getBufferOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::BufferCaptureDescriptorDataInfoEXT * pInfo, void * pData, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10486 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10487 template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10488 VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type getBufferOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::BufferCaptureDescriptorDataInfoEXT & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10489 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10490
10491
10492 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10493 VULKAN_HPP_NODISCARD Result getImageOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::ImageCaptureDescriptorDataInfoEXT * pInfo, void * pData, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10494 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10495 template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10496 VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type getImageOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::ImageCaptureDescriptorDataInfoEXT & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10497 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10498
10499
10500 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10501 VULKAN_HPP_NODISCARD Result getImageViewOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::ImageViewCaptureDescriptorDataInfoEXT * pInfo, void * pData, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10502 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10503 template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10504 VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type getImageViewOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::ImageViewCaptureDescriptorDataInfoEXT & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10505 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10506
10507
10508 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10509 VULKAN_HPP_NODISCARD Result getSamplerOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::SamplerCaptureDescriptorDataInfoEXT * pInfo, void * pData, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10510 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10511 template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10512 VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type getSamplerOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::SamplerCaptureDescriptorDataInfoEXT & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10513 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10514
10515
10516 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10517 VULKAN_HPP_NODISCARD Result getAccelerationStructureOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::AccelerationStructureCaptureDescriptorDataInfoEXT * pInfo, void * pData, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10518 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10519 template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10520 VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type getAccelerationStructureOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::AccelerationStructureCaptureDescriptorDataInfoEXT & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10521 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10522
10523 //=== VK_EXT_device_fault ===
10524
10525
10526 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10527 VULKAN_HPP_NODISCARD Result getFaultInfoEXT( VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT * pFaultCounts, VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT * pFaultInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10528 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10529 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10530 VULKAN_HPP_NODISCARD ResultValue<std::pair<VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT, VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT>> getFaultInfoEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10531 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10532
10533 #if defined( VK_USE_PLATFORM_FUCHSIA )
10534 //=== VK_FUCHSIA_external_memory ===
10535
10536
10537 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10538 VULKAN_HPP_NODISCARD Result getMemoryZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo, zx_handle_t * pZirconHandle, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10539 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10540 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10541 VULKAN_HPP_NODISCARD typename ResultValueType<zx_handle_t>::type getMemoryZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA & getZirconHandleInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10542 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10543
10544
10545 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10546 VULKAN_HPP_NODISCARD Result getMemoryZirconHandlePropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, zx_handle_t zirconHandle, VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA * pMemoryZirconHandleProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10547 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10548 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10549 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA>::type getMemoryZirconHandlePropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, zx_handle_t zirconHandle, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10550 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10551 #endif /*VK_USE_PLATFORM_FUCHSIA*/
10552
10553 #if defined( VK_USE_PLATFORM_FUCHSIA )
10554 //=== VK_FUCHSIA_external_semaphore ===
10555
10556
10557 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10558 VULKAN_HPP_NODISCARD Result importSemaphoreZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA * pImportSemaphoreZirconHandleInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10559 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10560 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10561 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type importSemaphoreZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA & importSemaphoreZirconHandleInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10562 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10563
10564
10565 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10566 VULKAN_HPP_NODISCARD Result getSemaphoreZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo, zx_handle_t * pZirconHandle, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10567 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10568 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10569 VULKAN_HPP_NODISCARD typename ResultValueType<zx_handle_t>::type getSemaphoreZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA & getZirconHandleInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10570 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10571 #endif /*VK_USE_PLATFORM_FUCHSIA*/
10572
10573 #if defined( VK_USE_PLATFORM_FUCHSIA )
10574 //=== VK_FUCHSIA_buffer_collection ===
10575
10576
10577 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10578 VULKAN_HPP_NODISCARD Result createBufferCollectionFUCHSIA( const VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA * pCollection, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10579 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10580 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10581 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA>::type createBufferCollectionFUCHSIA( const VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10582 # ifndef VULKAN_HPP_NO_SMART_HANDLE
10583 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10584 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA, Dispatch>>::type createBufferCollectionFUCHSIAUnique( const VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10585 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
10586 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10587
10588
10589 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10590 VULKAN_HPP_NODISCARD Result setBufferCollectionImageConstraintsFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection, const VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA * pImageConstraintsInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10591 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10592 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10593 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type setBufferCollectionImageConstraintsFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection, const VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA & imageConstraintsInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10594 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10595
10596
10597 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10598 VULKAN_HPP_NODISCARD Result setBufferCollectionBufferConstraintsFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection, const VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA * pBufferConstraintsInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10599 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10600 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10601 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type setBufferCollectionBufferConstraintsFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection, const VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA & bufferConstraintsInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10602 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10603
10604
10605 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10606 void destroyBufferCollectionFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10607 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10608 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10609 void destroyBufferCollectionFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10610 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10611
10612
10613 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10614 void destroy( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10615 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10616 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10617 void destroy( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10618 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10619
10620
10621 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10622 VULKAN_HPP_NODISCARD Result getBufferCollectionPropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection, VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA * pProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10623 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10624 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10625 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA>::type getBufferCollectionPropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10626 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10627 #endif /*VK_USE_PLATFORM_FUCHSIA*/
10628
10629 //=== VK_HUAWEI_subpass_shading ===
10630
10631
10632 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10633 VULKAN_HPP_NODISCARD Result getSubpassShadingMaxWorkgroupSizeHUAWEI( VULKAN_HPP_NAMESPACE::RenderPass renderpass, VULKAN_HPP_NAMESPACE::Extent2D * pMaxWorkgroupSize, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10634 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10635 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10636 VULKAN_HPP_NODISCARD ResultValue<VULKAN_HPP_NAMESPACE::Extent2D> getSubpassShadingMaxWorkgroupSizeHUAWEI( VULKAN_HPP_NAMESPACE::RenderPass renderpass, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10637 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10638
10639 //=== VK_NV_external_memory_rdma ===
10640
10641
10642 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10643 VULKAN_HPP_NODISCARD Result getMemoryRemoteAddressNV( const VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV * pMemoryGetRemoteAddressInfo, VULKAN_HPP_NAMESPACE::RemoteAddressNV * pAddress, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10644 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10645 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10646 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::RemoteAddressNV>::type getMemoryRemoteAddressNV( const VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV & memoryGetRemoteAddressInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10647 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10648
10649 //=== VK_EXT_pipeline_properties ===
10650
10651
10652 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10653 VULKAN_HPP_NODISCARD Result getPipelinePropertiesEXT( const VULKAN_HPP_NAMESPACE::PipelineInfoEXT * pPipelineInfo, VULKAN_HPP_NAMESPACE::BaseOutStructure * pPipelineProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10654 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10655 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10656 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::BaseOutStructure>::type getPipelinePropertiesEXT( const VULKAN_HPP_NAMESPACE::PipelineInfoEXT & pipelineInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10657 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10658
10659 //=== VK_EXT_opacity_micromap ===
10660
10661
10662 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10663 VULKAN_HPP_NODISCARD Result createMicromapEXT( const VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::MicromapEXT * pMicromap, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10664 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10665 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10666 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::MicromapEXT>::type createMicromapEXT( const VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10667 # ifndef VULKAN_HPP_NO_SMART_HANDLE
10668 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10669 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::MicromapEXT, Dispatch>>::type createMicromapEXTUnique( const VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10670 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
10671 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10672
10673
10674 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10675 void destroyMicromapEXT( VULKAN_HPP_NAMESPACE::MicromapEXT micromap, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10676 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10677 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10678 void destroyMicromapEXT( VULKAN_HPP_NAMESPACE::MicromapEXT micromap VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10679 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10680
10681
10682 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10683 void destroy( VULKAN_HPP_NAMESPACE::MicromapEXT micromap, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10684 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10685 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10686 void destroy( VULKAN_HPP_NAMESPACE::MicromapEXT micromap, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10687 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10688
10689
10690 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10691 VULKAN_HPP_NODISCARD Result buildMicromapsEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, uint32_t infoCount, const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT * pInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10692 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10693 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10694 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result buildMicromapsEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT> const & infos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10695 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10696
10697
10698 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10699 VULKAN_HPP_NODISCARD Result copyMicromapEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, const VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT * pInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10700 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10701 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10702 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result copyMicromapEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, const VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10703 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10704
10705
10706 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10707 VULKAN_HPP_NODISCARD Result copyMicromapToMemoryEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, const VULKAN_HPP_NAMESPACE::CopyMicromapToMemoryInfoEXT * pInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10708 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10709 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10710 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result copyMicromapToMemoryEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, const VULKAN_HPP_NAMESPACE::CopyMicromapToMemoryInfoEXT & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10711 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10712
10713
10714 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10715 VULKAN_HPP_NODISCARD Result copyMemoryToMicromapEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, const VULKAN_HPP_NAMESPACE::CopyMemoryToMicromapInfoEXT * pInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10716 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10717 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10718 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result copyMemoryToMicromapEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, const VULKAN_HPP_NAMESPACE::CopyMemoryToMicromapInfoEXT & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10719 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10720
10721
10722 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10723 VULKAN_HPP_NODISCARD Result writeMicromapsPropertiesEXT( uint32_t micromapCount, const VULKAN_HPP_NAMESPACE::MicromapEXT * pMicromaps, VULKAN_HPP_NAMESPACE::QueryType queryType, size_t dataSize, void * pData, size_t stride, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10724 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10725 template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10726 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type writeMicromapsPropertiesEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapEXT> const & micromaps, VULKAN_HPP_NAMESPACE::QueryType queryType, size_t dataSize, size_t stride, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10727 template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10728 VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type writeMicromapsPropertyEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapEXT> const & micromaps, VULKAN_HPP_NAMESPACE::QueryType queryType, size_t stride, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10729 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10730
10731
10732 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10733 void getMicromapCompatibilityEXT( const VULKAN_HPP_NAMESPACE::MicromapVersionInfoEXT * pVersionInfo, VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR * pCompatibility, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10734 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10735 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10736 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR getMicromapCompatibilityEXT( const VULKAN_HPP_NAMESPACE::MicromapVersionInfoEXT & versionInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10737 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10738
10739
10740 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10741 void getMicromapBuildSizesEXT( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR buildType, const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT * pBuildInfo, VULKAN_HPP_NAMESPACE::MicromapBuildSizesInfoEXT * pSizeInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10742 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10743 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10744 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MicromapBuildSizesInfoEXT getMicromapBuildSizesEXT( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR buildType, const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT & buildInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10745 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10746
10747 //=== VK_EXT_pageable_device_local_memory ===
10748
10749
10750 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10751 void setMemoryPriorityEXT( VULKAN_HPP_NAMESPACE::DeviceMemory memory, float priority, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10752
10753 //=== VK_KHR_maintenance4 ===
10754
10755
10756 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10757 void getBufferMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements * pInfo, VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10758 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10759 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10760 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getBufferMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10761 template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10762 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getBufferMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10763 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10764
10765
10766 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10767 void getImageMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements * pInfo, VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10768 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10769 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10770 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getImageMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10771 template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10772 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getImageMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10773 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10774
10775
10776 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10777 void getImageSparseMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements * pInfo, uint32_t * pSparseMemoryRequirementCount, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 * pSparseMemoryRequirements, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10778 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10779 template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10780 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> getImageSparseMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10781 template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = SparseImageMemoryRequirements2Allocator, typename std::enable_if<std::is_same<typename B1::value_type, SparseImageMemoryRequirements2>::value, int>::type = 0>
10782 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> getImageSparseMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info, SparseImageMemoryRequirements2Allocator & sparseImageMemoryRequirements2Allocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10783 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10784
10785 //=== VK_VALVE_descriptor_set_host_mapping ===
10786
10787
10788 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10789 void getDescriptorSetLayoutHostMappingInfoVALVE( const VULKAN_HPP_NAMESPACE::DescriptorSetBindingReferenceVALVE * pBindingReference, VULKAN_HPP_NAMESPACE::DescriptorSetLayoutHostMappingInfoVALVE * pHostMapping, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10790 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10791 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10792 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DescriptorSetLayoutHostMappingInfoVALVE getDescriptorSetLayoutHostMappingInfoVALVE( const VULKAN_HPP_NAMESPACE::DescriptorSetBindingReferenceVALVE & bindingReference, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10793 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10794
10795
10796 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10797 void getDescriptorSetHostMappingVALVE( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet, void ** ppData, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10798 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10799 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10800 VULKAN_HPP_NODISCARD void * getDescriptorSetHostMappingVALVE( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10801 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10802
10803 //=== VK_NV_device_generated_commands_compute ===
10804
10805
10806 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10807 void getPipelineIndirectMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo * pCreateInfo, VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10808 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10809 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10810 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getPipelineIndirectMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo & createInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10811 template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10812 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getPipelineIndirectMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo & createInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10813 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10814
10815
10816 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10817 DeviceAddress getPipelineIndirectAddressNV( const VULKAN_HPP_NAMESPACE::PipelineIndirectDeviceAddressInfoNV * pInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10818 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10819 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10820 VULKAN_HPP_NAMESPACE::DeviceAddress getPipelineIndirectAddressNV( const VULKAN_HPP_NAMESPACE::PipelineIndirectDeviceAddressInfoNV & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10821 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10822
10823 //=== VK_EXT_shader_module_identifier ===
10824
10825
10826 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10827 void getShaderModuleIdentifierEXT( VULKAN_HPP_NAMESPACE::ShaderModule shaderModule, VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT * pIdentifier, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10828 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10829 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10830 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT getShaderModuleIdentifierEXT( VULKAN_HPP_NAMESPACE::ShaderModule shaderModule, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10831 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10832
10833
10834 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10835 void getShaderModuleCreateInfoIdentifierEXT( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo * pCreateInfo, VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT * pIdentifier, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10836 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10837 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10838 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT getShaderModuleCreateInfoIdentifierEXT( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo & createInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10839 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10840
10841 //=== VK_NV_optical_flow ===
10842
10843
10844 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10845 VULKAN_HPP_NODISCARD Result createOpticalFlowSessionNV( const VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV * pSession, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10846 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10847 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10848 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV>::type createOpticalFlowSessionNV( const VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10849 # ifndef VULKAN_HPP_NO_SMART_HANDLE
10850 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10851 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV, Dispatch>>::type createOpticalFlowSessionNVUnique( const VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10852 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
10853 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10854
10855
10856 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10857 void destroyOpticalFlowSessionNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10858 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10859 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10860 void destroyOpticalFlowSessionNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10861 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10862
10863
10864 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10865 void destroy( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10866 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10867 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10868 void destroy( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10869 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10870
10871
10872 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
10873 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10874 VULKAN_HPP_NODISCARD Result bindOpticalFlowSessionImageNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session, VULKAN_HPP_NAMESPACE::OpticalFlowSessionBindingPointNV bindingPoint, VULKAN_HPP_NAMESPACE::ImageView view, VULKAN_HPP_NAMESPACE::ImageLayout layout, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10875 #else
10876 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10877 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type bindOpticalFlowSessionImageNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session, VULKAN_HPP_NAMESPACE::OpticalFlowSessionBindingPointNV bindingPoint, VULKAN_HPP_NAMESPACE::ImageView view, VULKAN_HPP_NAMESPACE::ImageLayout layout, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10878 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10879
10880 //=== VK_KHR_maintenance5 ===
10881
10882
10883 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10884 void getRenderingAreaGranularityKHR( const VULKAN_HPP_NAMESPACE::RenderingAreaInfoKHR * pRenderingAreaInfo, VULKAN_HPP_NAMESPACE::Extent2D * pGranularity, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10885 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10886 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10887 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Extent2D getRenderingAreaGranularityKHR( const VULKAN_HPP_NAMESPACE::RenderingAreaInfoKHR & renderingAreaInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10888 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10889
10890
10891 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10892 void getImageSubresourceLayoutKHR( const VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfoKHR * pInfo, VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR * pLayout, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10893 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10894 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10895 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR getImageSubresourceLayoutKHR( const VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfoKHR & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10896 template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10897 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getImageSubresourceLayoutKHR( const VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfoKHR & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10898 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10899
10900
10901 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10902 void getImageSubresourceLayout2KHR( VULKAN_HPP_NAMESPACE::Image image, const VULKAN_HPP_NAMESPACE::ImageSubresource2KHR * pSubresource, VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR * pLayout, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10903 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10904 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10905 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR getImageSubresourceLayout2KHR( VULKAN_HPP_NAMESPACE::Image image, const VULKAN_HPP_NAMESPACE::ImageSubresource2KHR & subresource, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10906 template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10907 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getImageSubresourceLayout2KHR( VULKAN_HPP_NAMESPACE::Image image, const VULKAN_HPP_NAMESPACE::ImageSubresource2KHR & subresource, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10908 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10909
10910 //=== VK_EXT_shader_object ===
10911
10912
10913 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10914 VULKAN_HPP_NODISCARD Result createShadersEXT( uint32_t createInfoCount, const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT * pCreateInfos, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::ShaderEXT * pShaders, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10915 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10916 template <typename ShaderEXTAllocator = std::allocator<VULKAN_HPP_NAMESPACE::ShaderEXT>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10917 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::ShaderEXT, ShaderEXTAllocator>>::type createShadersEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10918 template <typename ShaderEXTAllocator = std::allocator<VULKAN_HPP_NAMESPACE::ShaderEXT>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B0 = ShaderEXTAllocator, typename std::enable_if<std::is_same<typename B0::value_type, ShaderEXT>::value, int>::type = 0>
10919 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::ShaderEXT, ShaderEXTAllocator>>::type createShadersEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, ShaderEXTAllocator & shaderEXTAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10920 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10921 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ShaderEXT>::type createShaderEXT( const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10922 # ifndef VULKAN_HPP_NO_SMART_HANDLE
10923 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename ShaderEXTAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>>>
10924 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>, ShaderEXTAllocator>>::type createShadersEXTUnique( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10925 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename ShaderEXTAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>>, typename B0 = ShaderEXTAllocator, typename std::enable_if<std::is_same<typename B0::value_type, UniqueHandle<ShaderEXT, Dispatch>>::value, int>::type = 0>
10926 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>, ShaderEXTAllocator>>::type createShadersEXTUnique( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, ShaderEXTAllocator & shaderEXTAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10927 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10928 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>>::type createShaderEXTUnique( const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10929 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
10930 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10931
10932
10933 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10934 void destroyShaderEXT( VULKAN_HPP_NAMESPACE::ShaderEXT shader, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10935 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10936 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10937 void destroyShaderEXT( VULKAN_HPP_NAMESPACE::ShaderEXT shader, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10938 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10939
10940
10941 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10942 void destroy( VULKAN_HPP_NAMESPACE::ShaderEXT shader, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10943 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10944 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10945 void destroy( VULKAN_HPP_NAMESPACE::ShaderEXT shader, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10946 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10947
10948
10949 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10950 VULKAN_HPP_NODISCARD Result getShaderBinaryDataEXT( VULKAN_HPP_NAMESPACE::ShaderEXT shader, size_t * pDataSize, void * pData, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10951 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10952 template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10953 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type getShaderBinaryDataEXT( VULKAN_HPP_NAMESPACE::ShaderEXT shader, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10954 template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = Uint8_tAllocator, typename std::enable_if<std::is_same<typename B1::value_type, uint8_t>::value, int>::type = 0>
10955 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type getShaderBinaryDataEXT( VULKAN_HPP_NAMESPACE::ShaderEXT shader, Uint8_tAllocator & uint8_tAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10956 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10957
10958 //=== VK_QCOM_tile_properties ===
10959
10960
10961 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10962 VULKAN_HPP_NODISCARD Result getFramebufferTilePropertiesQCOM( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer, uint32_t * pPropertiesCount, VULKAN_HPP_NAMESPACE::TilePropertiesQCOM * pProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10963 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10964 template <typename TilePropertiesQCOMAllocator = std::allocator<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10965 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM, TilePropertiesQCOMAllocator>>::type getFramebufferTilePropertiesQCOM( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10966 template <typename TilePropertiesQCOMAllocator = std::allocator<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = TilePropertiesQCOMAllocator, typename std::enable_if<std::is_same<typename B1::value_type, TilePropertiesQCOM>::value, int>::type = 0>
10967 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM, TilePropertiesQCOMAllocator>>::type getFramebufferTilePropertiesQCOM( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer, TilePropertiesQCOMAllocator & tilePropertiesQCOMAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10968 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10969
10970
10971 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10972 Result getDynamicRenderingTilePropertiesQCOM( const VULKAN_HPP_NAMESPACE::RenderingInfo * pRenderingInfo, VULKAN_HPP_NAMESPACE::TilePropertiesQCOM * pProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10973 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10974 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10975 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::TilePropertiesQCOM getDynamicRenderingTilePropertiesQCOM( const VULKAN_HPP_NAMESPACE::RenderingInfo & renderingInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10976 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10977
10978 //=== VK_NV_low_latency2 ===
10979
10980
10981 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10982 VULKAN_HPP_NODISCARD Result setLatencySleepModeNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, const VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV * pSleepModeInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10983 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10984 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10985 typename ResultValueType<void>::type setLatencySleepModeNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, const VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV & sleepModeInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10986 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10987
10988
10989 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10990 VULKAN_HPP_NODISCARD Result latencySleepNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, const VULKAN_HPP_NAMESPACE::LatencySleepInfoNV * pSleepInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10991 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10992 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10993 typename ResultValueType<void>::type latencySleepNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, const VULKAN_HPP_NAMESPACE::LatencySleepInfoNV & sleepInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10994 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10995
10996
10997 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10998 void setLatencyMarkerNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, const VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV * pLatencyMarkerInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10999 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11000 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11001 void setLatencyMarkerNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, const VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV & latencyMarkerInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11002 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11003
11004
11005 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11006 void getLatencyTimingsNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, uint32_t * pTimingCount, VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV * pLatencyMarkerInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11007 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11008 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11009 VULKAN_HPP_NODISCARD std::pair<uint32_t, VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV> getLatencyTimingsNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11010 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11011
11012 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
11013 //=== VK_QNX_external_memory_screen_buffer ===
11014
11015
11016 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11017 VULKAN_HPP_NODISCARD Result getScreenBufferPropertiesQNX( const struct _screen_buffer * buffer, VULKAN_HPP_NAMESPACE::ScreenBufferPropertiesQNX * pProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11018 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11019 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11020 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ScreenBufferPropertiesQNX>::type getScreenBufferPropertiesQNX( const struct _screen_buffer & buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11021 template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11022 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>>::type getScreenBufferPropertiesQNX( const struct _screen_buffer & buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11023 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11024 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
11025
operator VkDevice() const11026 operator VkDevice() const VULKAN_HPP_NOEXCEPT
11027 {
11028 return m_device;
11029 }
11030
operator bool() const11031 explicit operator bool() const VULKAN_HPP_NOEXCEPT
11032 {
11033 return m_device != VK_NULL_HANDLE;
11034 }
11035
operator !() const11036 bool operator!() const VULKAN_HPP_NOEXCEPT
11037 {
11038 return m_device == VK_NULL_HANDLE;
11039 }
11040
11041 private:
11042 VkDevice m_device = {};
11043 };
11044
11045 template <>
11046 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDevice>
11047 {
11048 using Type = VULKAN_HPP_NAMESPACE::Device;
11049 };
11050
11051
11052 template <>
11053 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDevice>
11054 {
11055 using Type = VULKAN_HPP_NAMESPACE::Device;
11056 };
11057
11058
11059 template <>
11060 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Device>
11061 {
11062 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
11063 };
11064
11065 class DisplayModeKHR
11066 {
11067 public:
11068 using CType = VkDisplayModeKHR;
11069 using NativeType = VkDisplayModeKHR;
11070
11071 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDisplayModeKHR;
11072 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayModeKHR;
11073
11074 public:
11075 VULKAN_HPP_CONSTEXPR DisplayModeKHR() = default;
DisplayModeKHR(std::nullptr_t)11076 VULKAN_HPP_CONSTEXPR DisplayModeKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
11077 {}
DisplayModeKHR(VkDisplayModeKHR displayModeKHR)11078 VULKAN_HPP_TYPESAFE_EXPLICIT DisplayModeKHR( VkDisplayModeKHR displayModeKHR ) VULKAN_HPP_NOEXCEPT
11079 : m_displayModeKHR( displayModeKHR )
11080 {}
11081
11082 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkDisplayModeKHR displayModeKHR)11083 DisplayModeKHR & operator=(VkDisplayModeKHR displayModeKHR) VULKAN_HPP_NOEXCEPT
11084 {
11085 m_displayModeKHR = displayModeKHR;
11086 return *this;
11087 }
11088 #endif
11089
operator =(std::nullptr_t)11090 DisplayModeKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
11091 {
11092 m_displayModeKHR = {};
11093 return *this;
11094 }
11095
11096 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
11097 auto operator<=>( DisplayModeKHR const & ) const = default;
11098 #else
operator ==(DisplayModeKHR const & rhs) const11099 bool operator==( DisplayModeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
11100 {
11101 return m_displayModeKHR == rhs.m_displayModeKHR;
11102 }
11103
operator !=(DisplayModeKHR const & rhs) const11104 bool operator!=(DisplayModeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
11105 {
11106 return m_displayModeKHR != rhs.m_displayModeKHR;
11107 }
11108
operator <(DisplayModeKHR const & rhs) const11109 bool operator<(DisplayModeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
11110 {
11111 return m_displayModeKHR < rhs.m_displayModeKHR;
11112 }
11113 #endif
11114
operator VkDisplayModeKHR() const11115 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDisplayModeKHR() const VULKAN_HPP_NOEXCEPT
11116 {
11117 return m_displayModeKHR;
11118 }
11119
operator bool() const11120 explicit operator bool() const VULKAN_HPP_NOEXCEPT
11121 {
11122 return m_displayModeKHR != VK_NULL_HANDLE;
11123 }
11124
operator !() const11125 bool operator!() const VULKAN_HPP_NOEXCEPT
11126 {
11127 return m_displayModeKHR == VK_NULL_HANDLE;
11128 }
11129
11130 private:
11131 VkDisplayModeKHR m_displayModeKHR = {};
11132 };
11133
11134 template <>
11135 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDisplayModeKHR>
11136 {
11137 using Type = VULKAN_HPP_NAMESPACE::DisplayModeKHR;
11138 };
11139
11140
11141 template <>
11142 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayModeKHR>
11143 {
11144 using Type = VULKAN_HPP_NAMESPACE::DisplayModeKHR;
11145 };
11146
11147
11148 template <>
11149 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DisplayModeKHR>
11150 {
11151 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
11152 };
11153
11154 class PhysicalDevice
11155 {
11156 public:
11157 using CType = VkPhysicalDevice;
11158 using NativeType = VkPhysicalDevice;
11159
11160 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePhysicalDevice;
11161 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePhysicalDevice;
11162
11163 public:
11164 VULKAN_HPP_CONSTEXPR PhysicalDevice() = default;
PhysicalDevice(std::nullptr_t)11165 VULKAN_HPP_CONSTEXPR PhysicalDevice( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
11166 {}
PhysicalDevice(VkPhysicalDevice physicalDevice)11167 PhysicalDevice( VkPhysicalDevice physicalDevice ) VULKAN_HPP_NOEXCEPT
11168 : m_physicalDevice( physicalDevice )
11169 {}
11170
operator =(VkPhysicalDevice physicalDevice)11171 PhysicalDevice & operator=(VkPhysicalDevice physicalDevice) VULKAN_HPP_NOEXCEPT
11172 {
11173 m_physicalDevice = physicalDevice;
11174 return *this;
11175 }
11176
operator =(std::nullptr_t)11177 PhysicalDevice & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
11178 {
11179 m_physicalDevice = {};
11180 return *this;
11181 }
11182
11183 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
11184 auto operator<=>( PhysicalDevice const & ) const = default;
11185 #else
operator ==(PhysicalDevice const & rhs) const11186 bool operator==( PhysicalDevice const & rhs ) const VULKAN_HPP_NOEXCEPT
11187 {
11188 return m_physicalDevice == rhs.m_physicalDevice;
11189 }
11190
operator !=(PhysicalDevice const & rhs) const11191 bool operator!=(PhysicalDevice const & rhs ) const VULKAN_HPP_NOEXCEPT
11192 {
11193 return m_physicalDevice != rhs.m_physicalDevice;
11194 }
11195
operator <(PhysicalDevice const & rhs) const11196 bool operator<(PhysicalDevice const & rhs ) const VULKAN_HPP_NOEXCEPT
11197 {
11198 return m_physicalDevice < rhs.m_physicalDevice;
11199 }
11200 #endif
11201
11202 //=== VK_VERSION_1_0 ===
11203
11204
11205 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11206 void getFeatures( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures * pFeatures, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11207 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11208 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11209 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures getFeatures( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11210 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11211
11212
11213 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11214 void getFormatProperties( VULKAN_HPP_NAMESPACE::Format format, VULKAN_HPP_NAMESPACE::FormatProperties * pFormatProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11215 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11216 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11217 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::FormatProperties getFormatProperties( VULKAN_HPP_NAMESPACE::Format format, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11218 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11219
11220
11221 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11222 VULKAN_HPP_NODISCARD Result getImageFormatProperties( VULKAN_HPP_NAMESPACE::Format format, VULKAN_HPP_NAMESPACE::ImageType type, VULKAN_HPP_NAMESPACE::ImageTiling tiling, VULKAN_HPP_NAMESPACE::ImageUsageFlags usage, VULKAN_HPP_NAMESPACE::ImageCreateFlags flags, VULKAN_HPP_NAMESPACE::ImageFormatProperties * pImageFormatProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11223 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11224 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11225 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageFormatProperties>::type getImageFormatProperties( VULKAN_HPP_NAMESPACE::Format format, VULKAN_HPP_NAMESPACE::ImageType type, VULKAN_HPP_NAMESPACE::ImageTiling tiling, VULKAN_HPP_NAMESPACE::ImageUsageFlags usage, VULKAN_HPP_NAMESPACE::ImageCreateFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11226 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11227
11228
11229 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11230 void getProperties( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties * pProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11231 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11232 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11233 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties getProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11234 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11235
11236
11237 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11238 void getQueueFamilyProperties( uint32_t * pQueueFamilyPropertyCount, VULKAN_HPP_NAMESPACE::QueueFamilyProperties * pQueueFamilyProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11239 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11240 template <typename QueueFamilyPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::QueueFamilyProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11241 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties, QueueFamilyPropertiesAllocator> getQueueFamilyProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11242 template <typename QueueFamilyPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::QueueFamilyProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = QueueFamilyPropertiesAllocator, typename std::enable_if<std::is_same<typename B1::value_type, QueueFamilyProperties>::value, int>::type = 0>
11243 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties, QueueFamilyPropertiesAllocator> getQueueFamilyProperties( QueueFamilyPropertiesAllocator & queueFamilyPropertiesAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11244 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11245
11246
11247 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11248 void getMemoryProperties( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties * pMemoryProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11249 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11250 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11251 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties getMemoryProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11252 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11253
11254
11255 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11256 VULKAN_HPP_NODISCARD Result createDevice( const VULKAN_HPP_NAMESPACE::DeviceCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::Device * pDevice, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11257 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11258 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11259 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Device>::type createDevice( const VULKAN_HPP_NAMESPACE::DeviceCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11260 # ifndef VULKAN_HPP_NO_SMART_HANDLE
11261 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11262 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Device, Dispatch>>::type createDeviceUnique( const VULKAN_HPP_NAMESPACE::DeviceCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11263 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
11264 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11265
11266
11267 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11268 VULKAN_HPP_NODISCARD Result enumerateDeviceExtensionProperties( const char * pLayerName, uint32_t * pPropertyCount, VULKAN_HPP_NAMESPACE::ExtensionProperties * pProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11269 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11270 template <typename ExtensionPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::ExtensionProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11271 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties, ExtensionPropertiesAllocator>>::type enumerateDeviceExtensionProperties( Optional<const std::string> layerName VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11272 template <typename ExtensionPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::ExtensionProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = ExtensionPropertiesAllocator, typename std::enable_if<std::is_same<typename B1::value_type, ExtensionProperties>::value, int>::type = 0>
11273 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties, ExtensionPropertiesAllocator>>::type enumerateDeviceExtensionProperties( Optional<const std::string> layerName, ExtensionPropertiesAllocator & extensionPropertiesAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11274 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11275
11276
11277 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11278 VULKAN_HPP_NODISCARD Result enumerateDeviceLayerProperties( uint32_t * pPropertyCount, VULKAN_HPP_NAMESPACE::LayerProperties * pProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11279 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11280 template <typename LayerPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::LayerProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11281 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::LayerProperties, LayerPropertiesAllocator>>::type enumerateDeviceLayerProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11282 template <typename LayerPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::LayerProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = LayerPropertiesAllocator, typename std::enable_if<std::is_same<typename B1::value_type, LayerProperties>::value, int>::type = 0>
11283 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::LayerProperties, LayerPropertiesAllocator>>::type enumerateDeviceLayerProperties( LayerPropertiesAllocator & layerPropertiesAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11284 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11285
11286
11287 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11288 void getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format format, VULKAN_HPP_NAMESPACE::ImageType type, VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples, VULKAN_HPP_NAMESPACE::ImageUsageFlags usage, VULKAN_HPP_NAMESPACE::ImageTiling tiling, uint32_t * pPropertyCount, VULKAN_HPP_NAMESPACE::SparseImageFormatProperties * pProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11289 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11290 template <typename SparseImageFormatPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11291 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties, SparseImageFormatPropertiesAllocator> getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format format, VULKAN_HPP_NAMESPACE::ImageType type, VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples, VULKAN_HPP_NAMESPACE::ImageUsageFlags usage, VULKAN_HPP_NAMESPACE::ImageTiling tiling, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11292 template <typename SparseImageFormatPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = SparseImageFormatPropertiesAllocator, typename std::enable_if<std::is_same<typename B1::value_type, SparseImageFormatProperties>::value, int>::type = 0>
11293 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties, SparseImageFormatPropertiesAllocator> getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format format, VULKAN_HPP_NAMESPACE::ImageType type, VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples, VULKAN_HPP_NAMESPACE::ImageUsageFlags usage, VULKAN_HPP_NAMESPACE::ImageTiling tiling, SparseImageFormatPropertiesAllocator & sparseImageFormatPropertiesAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11294 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11295
11296 //=== VK_VERSION_1_1 ===
11297
11298
11299 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11300 void getFeatures2( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 * pFeatures, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11301 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11302 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11303 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 getFeatures2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11304 template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11305 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getFeatures2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11306 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11307
11308
11309 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11310 void getProperties2( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 * pProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11311 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11312 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11313 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 getProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11314 template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11315 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11316 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11317
11318
11319 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11320 void getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format, VULKAN_HPP_NAMESPACE::FormatProperties2 * pFormatProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11321 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11322 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11323 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::FormatProperties2 getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11324 template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11325 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11326 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11327
11328
11329 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11330 VULKAN_HPP_NODISCARD Result getImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 * pImageFormatInfo, VULKAN_HPP_NAMESPACE::ImageFormatProperties2 * pImageFormatProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11331 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11332 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11333 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>::type getImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11334 template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11335 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>>::type getImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11336 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11337
11338
11339 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11340 void getQueueFamilyProperties2( uint32_t * pQueueFamilyPropertyCount, VULKAN_HPP_NAMESPACE::QueueFamilyProperties2 * pQueueFamilyProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11341 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11342 template <typename QueueFamilyProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11343 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2, QueueFamilyProperties2Allocator> getQueueFamilyProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11344 template <typename QueueFamilyProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = QueueFamilyProperties2Allocator, typename std::enable_if<std::is_same<typename B1::value_type, QueueFamilyProperties2>::value, int>::type = 0>
11345 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2, QueueFamilyProperties2Allocator> getQueueFamilyProperties2( QueueFamilyProperties2Allocator & queueFamilyProperties2Allocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11346 template <typename StructureChain, typename StructureChainAllocator = std::allocator<StructureChain>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11347 VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator> getQueueFamilyProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11348 template <typename StructureChain, typename StructureChainAllocator = std::allocator<StructureChain>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = StructureChainAllocator, typename std::enable_if<std::is_same<typename B1::value_type, StructureChain>::value, int>::type = 0>
11349 VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator> getQueueFamilyProperties2( StructureChainAllocator & structureChainAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11350 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11351
11352
11353 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11354 void getMemoryProperties2( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 * pMemoryProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11355 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11356 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11357 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 getMemoryProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11358 template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11359 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getMemoryProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11360 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11361
11362
11363 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11364 void getSparseImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 * pFormatInfo, uint32_t * pPropertyCount, VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 * pProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11365 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11366 template <typename SparseImageFormatProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11367 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2, SparseImageFormatProperties2Allocator> getSparseImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11368 template <typename SparseImageFormatProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = SparseImageFormatProperties2Allocator, typename std::enable_if<std::is_same<typename B1::value_type, SparseImageFormatProperties2>::value, int>::type = 0>
11369 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2, SparseImageFormatProperties2Allocator> getSparseImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo, SparseImageFormatProperties2Allocator & sparseImageFormatProperties2Allocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11370 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11371
11372
11373 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11374 void getExternalBufferProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo * pExternalBufferInfo, VULKAN_HPP_NAMESPACE::ExternalBufferProperties * pExternalBufferProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11375 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11376 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11377 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalBufferProperties getExternalBufferProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo & externalBufferInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11378 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11379
11380
11381 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11382 void getExternalFenceProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo * pExternalFenceInfo, VULKAN_HPP_NAMESPACE::ExternalFenceProperties * pExternalFenceProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11383 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11384 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11385 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalFenceProperties getExternalFenceProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo & externalFenceInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11386 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11387
11388
11389 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11390 void getExternalSemaphoreProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo, VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties * pExternalSemaphoreProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11391 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11392 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11393 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties getExternalSemaphoreProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11394 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11395
11396 //=== VK_VERSION_1_3 ===
11397
11398
11399 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11400 VULKAN_HPP_NODISCARD Result getToolProperties( uint32_t * pToolCount, VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties * pToolProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11401 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11402 template <typename PhysicalDeviceToolPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11403 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator>>::type getToolProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11404 template <typename PhysicalDeviceToolPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = PhysicalDeviceToolPropertiesAllocator, typename std::enable_if<std::is_same<typename B1::value_type, PhysicalDeviceToolProperties>::value, int>::type = 0>
11405 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator>>::type getToolProperties( PhysicalDeviceToolPropertiesAllocator & physicalDeviceToolPropertiesAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11406 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11407
11408 //=== VK_KHR_surface ===
11409
11410
11411 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11412 VULKAN_HPP_NODISCARD Result getSurfaceSupportKHR( uint32_t queueFamilyIndex, VULKAN_HPP_NAMESPACE::SurfaceKHR surface, VULKAN_HPP_NAMESPACE::Bool32 * pSupported, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11413 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11414 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11415 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Bool32>::type getSurfaceSupportKHR( uint32_t queueFamilyIndex, VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11416 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11417
11418
11419 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11420 VULKAN_HPP_NODISCARD Result getSurfaceCapabilitiesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR * pSurfaceCapabilities, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11421 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11422 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11423 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR>::type getSurfaceCapabilitiesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11424 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11425
11426
11427 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11428 VULKAN_HPP_NODISCARD Result getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, uint32_t * pSurfaceFormatCount, VULKAN_HPP_NAMESPACE::SurfaceFormatKHR * pSurfaceFormats, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11429 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11430 template <typename SurfaceFormatKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11431 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR, SurfaceFormatKHRAllocator>>::type getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11432 template <typename SurfaceFormatKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = SurfaceFormatKHRAllocator, typename std::enable_if<std::is_same<typename B1::value_type, SurfaceFormatKHR>::value, int>::type = 0>
11433 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR, SurfaceFormatKHRAllocator>>::type getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, SurfaceFormatKHRAllocator & surfaceFormatKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11434 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11435
11436
11437 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11438 VULKAN_HPP_NODISCARD Result getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, uint32_t * pPresentModeCount, VULKAN_HPP_NAMESPACE::PresentModeKHR * pPresentModes, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11439 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11440 template <typename PresentModeKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PresentModeKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11441 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR, PresentModeKHRAllocator>>::type getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11442 template <typename PresentModeKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PresentModeKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = PresentModeKHRAllocator, typename std::enable_if<std::is_same<typename B1::value_type, PresentModeKHR>::value, int>::type = 0>
11443 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR, PresentModeKHRAllocator>>::type getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, PresentModeKHRAllocator & presentModeKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11444 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11445
11446 //=== VK_KHR_swapchain ===
11447
11448
11449 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11450 VULKAN_HPP_NODISCARD Result getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, uint32_t * pRectCount, VULKAN_HPP_NAMESPACE::Rect2D * pRects, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11451 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11452 template <typename Rect2DAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Rect2D>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11453 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::Rect2D, Rect2DAllocator>>::type getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11454 template <typename Rect2DAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Rect2D>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = Rect2DAllocator, typename std::enable_if<std::is_same<typename B1::value_type, Rect2D>::value, int>::type = 0>
11455 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::Rect2D, Rect2DAllocator>>::type getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Rect2DAllocator & rect2DAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11456 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11457
11458 //=== VK_KHR_display ===
11459
11460
11461 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11462 VULKAN_HPP_NODISCARD Result getDisplayPropertiesKHR( uint32_t * pPropertyCount, VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR * pProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11463 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11464 template <typename DisplayPropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11465 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR, DisplayPropertiesKHRAllocator>>::type getDisplayPropertiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11466 template <typename DisplayPropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = DisplayPropertiesKHRAllocator, typename std::enable_if<std::is_same<typename B1::value_type, DisplayPropertiesKHR>::value, int>::type = 0>
11467 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR, DisplayPropertiesKHRAllocator>>::type getDisplayPropertiesKHR( DisplayPropertiesKHRAllocator & displayPropertiesKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11468 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11469
11470
11471 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11472 VULKAN_HPP_NODISCARD Result getDisplayPlanePropertiesKHR( uint32_t * pPropertyCount, VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR * pProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11473 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11474 template <typename DisplayPlanePropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11475 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR, DisplayPlanePropertiesKHRAllocator>>::type getDisplayPlanePropertiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11476 template <typename DisplayPlanePropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = DisplayPlanePropertiesKHRAllocator, typename std::enable_if<std::is_same<typename B1::value_type, DisplayPlanePropertiesKHR>::value, int>::type = 0>
11477 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR, DisplayPlanePropertiesKHRAllocator>>::type getDisplayPlanePropertiesKHR( DisplayPlanePropertiesKHRAllocator & displayPlanePropertiesKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11478 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11479
11480
11481 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11482 VULKAN_HPP_NODISCARD Result getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, uint32_t * pDisplayCount, VULKAN_HPP_NAMESPACE::DisplayKHR * pDisplays, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11483 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11484 template <typename DisplayKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11485 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayKHR, DisplayKHRAllocator>>::type getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11486 template <typename DisplayKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = DisplayKHRAllocator, typename std::enable_if<std::is_same<typename B1::value_type, DisplayKHR>::value, int>::type = 0>
11487 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayKHR, DisplayKHRAllocator>>::type getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, DisplayKHRAllocator & displayKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11488 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11489
11490
11491 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11492 VULKAN_HPP_NODISCARD Result getDisplayModePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, uint32_t * pPropertyCount, VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR * pProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11493 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11494 template <typename DisplayModePropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11495 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR, DisplayModePropertiesKHRAllocator>>::type getDisplayModePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11496 template <typename DisplayModePropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = DisplayModePropertiesKHRAllocator, typename std::enable_if<std::is_same<typename B1::value_type, DisplayModePropertiesKHR>::value, int>::type = 0>
11497 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR, DisplayModePropertiesKHRAllocator>>::type getDisplayModePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, DisplayModePropertiesKHRAllocator & displayModePropertiesKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11498 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11499
11500
11501 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11502 VULKAN_HPP_NODISCARD Result createDisplayModeKHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, const VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::DisplayModeKHR * pMode, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11503 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11504 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11505 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayModeKHR>::type createDisplayModeKHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, const VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11506 # ifndef VULKAN_HPP_NO_SMART_HANDLE
11507 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11508 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayModeKHR, Dispatch>>::type createDisplayModeKHRUnique( VULKAN_HPP_NAMESPACE::DisplayKHR display, const VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, 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
11513 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11514 VULKAN_HPP_NODISCARD Result getDisplayPlaneCapabilitiesKHR( VULKAN_HPP_NAMESPACE::DisplayModeKHR mode, uint32_t planeIndex, VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR * pCapabilities, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11515 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11516 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11517 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR>::type getDisplayPlaneCapabilitiesKHR( VULKAN_HPP_NAMESPACE::DisplayModeKHR mode, uint32_t planeIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11518 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11519
11520 #if defined( VK_USE_PLATFORM_XLIB_KHR )
11521 //=== VK_KHR_xlib_surface ===
11522
11523
11524 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11525 Bool32 getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display * dpy, VisualID visualID, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11526 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11527 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11528 VULKAN_HPP_NAMESPACE::Bool32 getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display & dpy, VisualID visualID, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11529 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11530 #endif /*VK_USE_PLATFORM_XLIB_KHR*/
11531
11532 #if defined( VK_USE_PLATFORM_XCB_KHR )
11533 //=== VK_KHR_xcb_surface ===
11534
11535
11536 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11537 Bool32 getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, xcb_connection_t * connection, xcb_visualid_t visual_id, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11538 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11539 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11540 VULKAN_HPP_NAMESPACE::Bool32 getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, xcb_connection_t & connection, xcb_visualid_t visual_id, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11541 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11542 #endif /*VK_USE_PLATFORM_XCB_KHR*/
11543
11544 #if defined( VK_USE_PLATFORM_WAYLAND_KHR )
11545 //=== VK_KHR_wayland_surface ===
11546
11547
11548 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11549 Bool32 getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, struct wl_display * display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11550 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11551 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11552 VULKAN_HPP_NAMESPACE::Bool32 getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, struct wl_display & display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11553 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11554 #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
11555
11556 #if defined( VK_USE_PLATFORM_WIN32_KHR )
11557 //=== VK_KHR_win32_surface ===
11558
11559
11560 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11561 Bool32 getWin32PresentationSupportKHR( uint32_t queueFamilyIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11562 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
11563
11564 //=== VK_KHR_video_queue ===
11565
11566
11567 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11568 VULKAN_HPP_NODISCARD Result getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR * pVideoProfile, VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR * pCapabilities, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11569 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11570 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11571 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR>::type getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR & videoProfile, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11572 template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11573 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>>::type getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR & videoProfile, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11574 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11575
11576
11577 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11578 VULKAN_HPP_NODISCARD Result getVideoFormatPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR * pVideoFormatInfo, uint32_t * pVideoFormatPropertyCount, VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR * pVideoFormatProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11579 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11580 template <typename VideoFormatPropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11581 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR, VideoFormatPropertiesKHRAllocator>>::type getVideoFormatPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11582 template <typename VideoFormatPropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = VideoFormatPropertiesKHRAllocator, typename std::enable_if<std::is_same<typename B1::value_type, VideoFormatPropertiesKHR>::value, int>::type = 0>
11583 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR, VideoFormatPropertiesKHRAllocator>>::type getVideoFormatPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo, VideoFormatPropertiesKHRAllocator & videoFormatPropertiesKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11584 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11585
11586 //=== VK_NV_external_memory_capabilities ===
11587
11588
11589 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11590 VULKAN_HPP_NODISCARD Result getExternalImageFormatPropertiesNV( VULKAN_HPP_NAMESPACE::Format format, VULKAN_HPP_NAMESPACE::ImageType type, VULKAN_HPP_NAMESPACE::ImageTiling tiling, VULKAN_HPP_NAMESPACE::ImageUsageFlags usage, VULKAN_HPP_NAMESPACE::ImageCreateFlags flags, VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV externalHandleType, VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV * pExternalImageFormatProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11591 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11592 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11593 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV>::type getExternalImageFormatPropertiesNV( VULKAN_HPP_NAMESPACE::Format format, VULKAN_HPP_NAMESPACE::ImageType type, VULKAN_HPP_NAMESPACE::ImageTiling tiling, VULKAN_HPP_NAMESPACE::ImageUsageFlags usage, VULKAN_HPP_NAMESPACE::ImageCreateFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV externalHandleType VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11594 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11595
11596 //=== VK_KHR_get_physical_device_properties2 ===
11597
11598
11599 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11600 void getFeatures2KHR( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 * pFeatures, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11601 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11602 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11603 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 getFeatures2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11604 template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11605 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getFeatures2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11606 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11607
11608
11609 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11610 void getProperties2KHR( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 * pProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11611 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11612 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11613 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 getProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11614 template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11615 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11616 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11617
11618
11619 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11620 void getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format, VULKAN_HPP_NAMESPACE::FormatProperties2 * pFormatProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11621 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11622 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11623 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::FormatProperties2 getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11624 template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11625 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11626 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11627
11628
11629 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11630 VULKAN_HPP_NODISCARD Result getImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 * pImageFormatInfo, VULKAN_HPP_NAMESPACE::ImageFormatProperties2 * pImageFormatProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11631 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11632 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11633 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>::type getImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11634 template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11635 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>>::type getImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11636 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11637
11638
11639 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11640 void getQueueFamilyProperties2KHR( uint32_t * pQueueFamilyPropertyCount, VULKAN_HPP_NAMESPACE::QueueFamilyProperties2 * pQueueFamilyProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11641 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11642 template <typename QueueFamilyProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11643 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2, QueueFamilyProperties2Allocator> getQueueFamilyProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11644 template <typename QueueFamilyProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = QueueFamilyProperties2Allocator, typename std::enable_if<std::is_same<typename B1::value_type, QueueFamilyProperties2>::value, int>::type = 0>
11645 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2, QueueFamilyProperties2Allocator> getQueueFamilyProperties2KHR( QueueFamilyProperties2Allocator & queueFamilyProperties2Allocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11646 template <typename StructureChain, typename StructureChainAllocator = std::allocator<StructureChain>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11647 VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator> getQueueFamilyProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11648 template <typename StructureChain, typename StructureChainAllocator = std::allocator<StructureChain>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = StructureChainAllocator, typename std::enable_if<std::is_same<typename B1::value_type, StructureChain>::value, int>::type = 0>
11649 VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator> getQueueFamilyProperties2KHR( StructureChainAllocator & structureChainAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11650 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11651
11652
11653 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11654 void getMemoryProperties2KHR( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 * pMemoryProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11655 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11656 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11657 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 getMemoryProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11658 template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11659 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getMemoryProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11660 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11661
11662
11663 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11664 void getSparseImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 * pFormatInfo, uint32_t * pPropertyCount, VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 * pProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11665 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11666 template <typename SparseImageFormatProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11667 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2, SparseImageFormatProperties2Allocator> getSparseImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11668 template <typename SparseImageFormatProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = SparseImageFormatProperties2Allocator, typename std::enable_if<std::is_same<typename B1::value_type, SparseImageFormatProperties2>::value, int>::type = 0>
11669 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2, SparseImageFormatProperties2Allocator> getSparseImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo, SparseImageFormatProperties2Allocator & sparseImageFormatProperties2Allocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11670 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11671
11672 //=== VK_KHR_external_memory_capabilities ===
11673
11674
11675 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11676 void getExternalBufferPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo * pExternalBufferInfo, VULKAN_HPP_NAMESPACE::ExternalBufferProperties * pExternalBufferProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11677 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11678 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11679 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalBufferProperties getExternalBufferPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo & externalBufferInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11680 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11681
11682 //=== VK_KHR_external_semaphore_capabilities ===
11683
11684
11685 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11686 void getExternalSemaphorePropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo, VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties * pExternalSemaphoreProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11687 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11688 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11689 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties getExternalSemaphorePropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11690 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11691
11692 //=== VK_EXT_direct_mode_display ===
11693
11694
11695 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
11696 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11697 Result releaseDisplayEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11698 #else
11699 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11700 void releaseDisplayEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11701 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11702
11703 #if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT )
11704 //=== VK_EXT_acquire_xlib_display ===
11705
11706
11707 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11708 VULKAN_HPP_NODISCARD Result acquireXlibDisplayEXT( Display * dpy, VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11709 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11710 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11711 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type acquireXlibDisplayEXT( Display & dpy, VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11712 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11713
11714
11715 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11716 VULKAN_HPP_NODISCARD Result getRandROutputDisplayEXT( Display * dpy, RROutput rrOutput, VULKAN_HPP_NAMESPACE::DisplayKHR * pDisplay, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11717 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11718 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11719 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayKHR>::type getRandROutputDisplayEXT( Display & dpy, RROutput rrOutput, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11720 # ifndef VULKAN_HPP_NO_SMART_HANDLE
11721 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11722 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>>::type getRandROutputDisplayEXTUnique( Display & dpy, RROutput rrOutput, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11723 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
11724 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11725 #endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
11726
11727 //=== VK_EXT_display_surface_counter ===
11728
11729
11730 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11731 VULKAN_HPP_NODISCARD Result getSurfaceCapabilities2EXT( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT * pSurfaceCapabilities, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11732 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11733 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11734 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT>::type getSurfaceCapabilities2EXT( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11735 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11736
11737 //=== VK_KHR_external_fence_capabilities ===
11738
11739
11740 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11741 void getExternalFencePropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo * pExternalFenceInfo, VULKAN_HPP_NAMESPACE::ExternalFenceProperties * pExternalFenceProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11742 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11743 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11744 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalFenceProperties getExternalFencePropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo & externalFenceInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11745 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11746
11747 //=== VK_KHR_performance_query ===
11748
11749
11750 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11751 VULKAN_HPP_NODISCARD Result enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex, uint32_t * pCounterCount, VULKAN_HPP_NAMESPACE::PerformanceCounterKHR * pCounters, VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR * pCounterDescriptions, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11752 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11753 template <typename PerformanceCounterKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR>, typename PerformanceCounterDescriptionKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11754 VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR, PerformanceCounterKHRAllocator>, std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator>>>::type enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11755 template <typename PerformanceCounterKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR>, typename PerformanceCounterDescriptionKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = PerformanceCounterKHRAllocator, typename B2 = PerformanceCounterDescriptionKHRAllocator, typename std::enable_if<std::is_same<typename B1::value_type, PerformanceCounterKHR>::value && std::is_same<typename B2::value_type, PerformanceCounterDescriptionKHR>::value, int>::type = 0>
11756 VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR, PerformanceCounterKHRAllocator>, std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator>>>::type enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex, PerformanceCounterKHRAllocator & performanceCounterKHRAllocator, PerformanceCounterDescriptionKHRAllocator & performanceCounterDescriptionKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11757 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11758
11759
11760 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11761 void getQueueFamilyPerformanceQueryPassesKHR( const VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR * pPerformanceQueryCreateInfo, uint32_t * pNumPasses, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11762 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11763 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11764 VULKAN_HPP_NODISCARD uint32_t getQueueFamilyPerformanceQueryPassesKHR( const VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR & performanceQueryCreateInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11765 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11766
11767 //=== VK_KHR_get_surface_capabilities2 ===
11768
11769
11770 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11771 VULKAN_HPP_NODISCARD Result getSurfaceCapabilities2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo, VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR * pSurfaceCapabilities, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11772 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11773 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11774 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR>::type getSurfaceCapabilities2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11775 template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11776 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>>::type getSurfaceCapabilities2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11777 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11778
11779
11780 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11781 VULKAN_HPP_NODISCARD Result getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo, uint32_t * pSurfaceFormatCount, VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR * pSurfaceFormats, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11782 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11783 template <typename SurfaceFormat2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11784 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR, SurfaceFormat2KHRAllocator>>::type getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11785 template <typename SurfaceFormat2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = SurfaceFormat2KHRAllocator, typename std::enable_if<std::is_same<typename B1::value_type, SurfaceFormat2KHR>::value, int>::type = 0>
11786 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR, SurfaceFormat2KHRAllocator>>::type getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, SurfaceFormat2KHRAllocator & surfaceFormat2KHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11787 template <typename StructureChain, typename StructureChainAllocator = std::allocator<StructureChain>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11788 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<StructureChain, StructureChainAllocator>>::type getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11789 template <typename StructureChain, typename StructureChainAllocator = std::allocator<StructureChain>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = StructureChainAllocator, typename std::enable_if<std::is_same<typename B1::value_type, StructureChain>::value, int>::type = 0>
11790 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<StructureChain, StructureChainAllocator>>::type getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, StructureChainAllocator & structureChainAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11791 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11792
11793 //=== VK_KHR_get_display_properties2 ===
11794
11795
11796 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11797 VULKAN_HPP_NODISCARD Result getDisplayProperties2KHR( uint32_t * pPropertyCount, VULKAN_HPP_NAMESPACE::DisplayProperties2KHR * pProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11798 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11799 template <typename DisplayProperties2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11800 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR, DisplayProperties2KHRAllocator>>::type getDisplayProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11801 template <typename DisplayProperties2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = DisplayProperties2KHRAllocator, typename std::enable_if<std::is_same<typename B1::value_type, DisplayProperties2KHR>::value, int>::type = 0>
11802 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR, DisplayProperties2KHRAllocator>>::type getDisplayProperties2KHR( DisplayProperties2KHRAllocator & displayProperties2KHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11803 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11804
11805
11806 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11807 VULKAN_HPP_NODISCARD Result getDisplayPlaneProperties2KHR( uint32_t * pPropertyCount, VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR * pProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11808 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11809 template <typename DisplayPlaneProperties2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11810 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR, DisplayPlaneProperties2KHRAllocator>>::type getDisplayPlaneProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11811 template <typename DisplayPlaneProperties2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = DisplayPlaneProperties2KHRAllocator, typename std::enable_if<std::is_same<typename B1::value_type, DisplayPlaneProperties2KHR>::value, int>::type = 0>
11812 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR, DisplayPlaneProperties2KHRAllocator>>::type getDisplayPlaneProperties2KHR( DisplayPlaneProperties2KHRAllocator & displayPlaneProperties2KHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11813 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11814
11815
11816 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11817 VULKAN_HPP_NODISCARD Result getDisplayModeProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, uint32_t * pPropertyCount, VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR * pProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11818 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11819 template <typename DisplayModeProperties2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11820 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR, DisplayModeProperties2KHRAllocator>>::type getDisplayModeProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11821 template <typename DisplayModeProperties2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = DisplayModeProperties2KHRAllocator, typename std::enable_if<std::is_same<typename B1::value_type, DisplayModeProperties2KHR>::value, int>::type = 0>
11822 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR, DisplayModeProperties2KHRAllocator>>::type getDisplayModeProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, DisplayModeProperties2KHRAllocator & displayModeProperties2KHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11823 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11824
11825
11826 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11827 VULKAN_HPP_NODISCARD Result getDisplayPlaneCapabilities2KHR( const VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR * pDisplayPlaneInfo, VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR * pCapabilities, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11828 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11829 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11830 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR>::type getDisplayPlaneCapabilities2KHR( const VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR & displayPlaneInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11831 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11832
11833 //=== VK_EXT_sample_locations ===
11834
11835
11836 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11837 void getMultisamplePropertiesEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples, VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT * pMultisampleProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11838 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11839 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11840 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT getMultisamplePropertiesEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11841 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11842
11843 //=== VK_EXT_calibrated_timestamps ===
11844
11845
11846 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11847 VULKAN_HPP_NODISCARD Result getCalibrateableTimeDomainsEXT( uint32_t * pTimeDomainCount, VULKAN_HPP_NAMESPACE::TimeDomainEXT * pTimeDomains, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11848 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11849 template <typename TimeDomainEXTAllocator = std::allocator<VULKAN_HPP_NAMESPACE::TimeDomainEXT>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11850 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TimeDomainEXT, TimeDomainEXTAllocator>>::type getCalibrateableTimeDomainsEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11851 template <typename TimeDomainEXTAllocator = std::allocator<VULKAN_HPP_NAMESPACE::TimeDomainEXT>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = TimeDomainEXTAllocator, typename std::enable_if<std::is_same<typename B1::value_type, TimeDomainEXT>::value, int>::type = 0>
11852 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TimeDomainEXT, TimeDomainEXTAllocator>>::type getCalibrateableTimeDomainsEXT( TimeDomainEXTAllocator & timeDomainEXTAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11853 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11854
11855 //=== VK_KHR_fragment_shading_rate ===
11856
11857
11858 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11859 VULKAN_HPP_NODISCARD Result getFragmentShadingRatesKHR( uint32_t * pFragmentShadingRateCount, VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR * pFragmentShadingRates, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11860 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11861 template <typename PhysicalDeviceFragmentShadingRateKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11862 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR, PhysicalDeviceFragmentShadingRateKHRAllocator>>::type getFragmentShadingRatesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11863 template <typename PhysicalDeviceFragmentShadingRateKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = PhysicalDeviceFragmentShadingRateKHRAllocator, typename std::enable_if<std::is_same<typename B1::value_type, PhysicalDeviceFragmentShadingRateKHR>::value, int>::type = 0>
11864 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR, PhysicalDeviceFragmentShadingRateKHRAllocator>>::type getFragmentShadingRatesKHR( PhysicalDeviceFragmentShadingRateKHRAllocator & physicalDeviceFragmentShadingRateKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11865 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11866
11867 //=== VK_EXT_tooling_info ===
11868
11869
11870 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11871 VULKAN_HPP_NODISCARD Result getToolPropertiesEXT( uint32_t * pToolCount, VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties * pToolProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11872 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11873 template <typename PhysicalDeviceToolPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11874 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator>>::type getToolPropertiesEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11875 template <typename PhysicalDeviceToolPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = PhysicalDeviceToolPropertiesAllocator, typename std::enable_if<std::is_same<typename B1::value_type, PhysicalDeviceToolProperties>::value, int>::type = 0>
11876 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator>>::type getToolPropertiesEXT( PhysicalDeviceToolPropertiesAllocator & physicalDeviceToolPropertiesAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11877 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11878
11879 //=== VK_NV_cooperative_matrix ===
11880
11881
11882 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11883 VULKAN_HPP_NODISCARD Result getCooperativeMatrixPropertiesNV( uint32_t * pPropertyCount, VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV * pProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11884 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11885 template <typename CooperativeMatrixPropertiesNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11886 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV, CooperativeMatrixPropertiesNVAllocator>>::type getCooperativeMatrixPropertiesNV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11887 template <typename CooperativeMatrixPropertiesNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = CooperativeMatrixPropertiesNVAllocator, typename std::enable_if<std::is_same<typename B1::value_type, CooperativeMatrixPropertiesNV>::value, int>::type = 0>
11888 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV, CooperativeMatrixPropertiesNVAllocator>>::type getCooperativeMatrixPropertiesNV( CooperativeMatrixPropertiesNVAllocator & cooperativeMatrixPropertiesNVAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11889 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11890
11891 //=== VK_NV_coverage_reduction_mode ===
11892
11893
11894 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11895 VULKAN_HPP_NODISCARD Result getSupportedFramebufferMixedSamplesCombinationsNV( uint32_t * pCombinationCount, VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV * pCombinations, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11896 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11897 template <typename FramebufferMixedSamplesCombinationNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11898 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV, FramebufferMixedSamplesCombinationNVAllocator>>::type getSupportedFramebufferMixedSamplesCombinationsNV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11899 template <typename FramebufferMixedSamplesCombinationNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = FramebufferMixedSamplesCombinationNVAllocator, typename std::enable_if<std::is_same<typename B1::value_type, FramebufferMixedSamplesCombinationNV>::value, int>::type = 0>
11900 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV, FramebufferMixedSamplesCombinationNVAllocator>>::type getSupportedFramebufferMixedSamplesCombinationsNV( FramebufferMixedSamplesCombinationNVAllocator & framebufferMixedSamplesCombinationNVAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11901 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11902
11903 #if defined( VK_USE_PLATFORM_WIN32_KHR )
11904 //=== VK_EXT_full_screen_exclusive ===
11905
11906
11907 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11908 VULKAN_HPP_NODISCARD Result getSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo, uint32_t * pPresentModeCount, VULKAN_HPP_NAMESPACE::PresentModeKHR * pPresentModes, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11909 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11910 template <typename PresentModeKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PresentModeKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11911 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR, PresentModeKHRAllocator>>::type getSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11912 template <typename PresentModeKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PresentModeKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = PresentModeKHRAllocator, typename std::enable_if<std::is_same<typename B1::value_type, PresentModeKHR>::value, int>::type = 0>
11913 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR, PresentModeKHRAllocator>>::type getSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, PresentModeKHRAllocator & presentModeKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11914 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11915 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
11916
11917 //=== VK_EXT_acquire_drm_display ===
11918
11919
11920 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
11921 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11922 VULKAN_HPP_NODISCARD Result acquireDrmDisplayEXT( int32_t drmFd, VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11923 #else
11924 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11925 typename ResultValueType<void>::type acquireDrmDisplayEXT( int32_t drmFd, VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11926 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11927
11928
11929 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11930 VULKAN_HPP_NODISCARD Result getDrmDisplayEXT( int32_t drmFd, uint32_t connectorId, VULKAN_HPP_NAMESPACE::DisplayKHR * display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11931 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11932 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11933 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayKHR>::type getDrmDisplayEXT( int32_t drmFd, uint32_t connectorId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11934 # ifndef VULKAN_HPP_NO_SMART_HANDLE
11935 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11936 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>>::type getDrmDisplayEXTUnique( int32_t drmFd, uint32_t connectorId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11937 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
11938 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11939
11940 #if defined( VK_ENABLE_BETA_EXTENSIONS )
11941 //=== VK_KHR_video_encode_queue ===
11942
11943
11944 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11945 VULKAN_HPP_NODISCARD Result getVideoEncodeQualityLevelPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR * pQualityLevelInfo, VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelPropertiesKHR * pQualityLevelProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11946 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11947 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11948 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelPropertiesKHR>::type getVideoEncodeQualityLevelPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR & qualityLevelInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11949 template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11950 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>>::type getVideoEncodeQualityLevelPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR & qualityLevelInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11951 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11952 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
11953
11954 #if defined( VK_USE_PLATFORM_WIN32_KHR )
11955 //=== VK_NV_acquire_winrt_display ===
11956
11957
11958 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
11959 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11960 VULKAN_HPP_NODISCARD Result acquireWinrtDisplayNV( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11961 #else
11962 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11963 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type acquireWinrtDisplayNV( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11964 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11965
11966
11967 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11968 VULKAN_HPP_NODISCARD Result getWinrtDisplayNV( uint32_t deviceRelativeId, VULKAN_HPP_NAMESPACE::DisplayKHR * pDisplay, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11969 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11970 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11971 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayKHR>::type getWinrtDisplayNV( uint32_t deviceRelativeId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11972 # ifndef VULKAN_HPP_NO_SMART_HANDLE
11973 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11974 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>>::type getWinrtDisplayNVUnique( uint32_t deviceRelativeId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11975 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
11976 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11977 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
11978
11979 #if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
11980 //=== VK_EXT_directfb_surface ===
11981
11982
11983 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11984 Bool32 getDirectFBPresentationSupportEXT( uint32_t queueFamilyIndex, IDirectFB * dfb, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11985 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11986 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11987 VULKAN_HPP_NAMESPACE::Bool32 getDirectFBPresentationSupportEXT( uint32_t queueFamilyIndex, IDirectFB & dfb, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11988 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11989 #endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
11990
11991 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
11992 //=== VK_QNX_screen_surface ===
11993
11994
11995 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11996 Bool32 getScreenPresentationSupportQNX( uint32_t queueFamilyIndex, struct _screen_window * window, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11997 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11998 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11999 VULKAN_HPP_NAMESPACE::Bool32 getScreenPresentationSupportQNX( uint32_t queueFamilyIndex, struct _screen_window & window, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12000 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12001 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
12002
12003 //=== VK_NV_optical_flow ===
12004
12005
12006 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12007 VULKAN_HPP_NODISCARD Result getOpticalFlowImageFormatsNV( const VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatInfoNV * pOpticalFlowImageFormatInfo, uint32_t * pFormatCount, VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV * pImageFormatProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12008 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12009 template <typename OpticalFlowImageFormatPropertiesNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12010 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV, OpticalFlowImageFormatPropertiesNVAllocator>>::type getOpticalFlowImageFormatsNV( const VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatInfoNV & opticalFlowImageFormatInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12011 template <typename OpticalFlowImageFormatPropertiesNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = OpticalFlowImageFormatPropertiesNVAllocator, typename std::enable_if<std::is_same<typename B1::value_type, OpticalFlowImageFormatPropertiesNV>::value, int>::type = 0>
12012 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV, OpticalFlowImageFormatPropertiesNVAllocator>>::type getOpticalFlowImageFormatsNV( const VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatInfoNV & opticalFlowImageFormatInfo, OpticalFlowImageFormatPropertiesNVAllocator & opticalFlowImageFormatPropertiesNVAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12013 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12014
12015 //=== VK_KHR_cooperative_matrix ===
12016
12017
12018 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12019 VULKAN_HPP_NODISCARD Result getCooperativeMatrixPropertiesKHR( uint32_t * pPropertyCount, VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR * pProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12020 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12021 template <typename CooperativeMatrixPropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12022 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR, CooperativeMatrixPropertiesKHRAllocator>>::type getCooperativeMatrixPropertiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12023 template <typename CooperativeMatrixPropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = CooperativeMatrixPropertiesKHRAllocator, typename std::enable_if<std::is_same<typename B1::value_type, CooperativeMatrixPropertiesKHR>::value, int>::type = 0>
12024 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR, CooperativeMatrixPropertiesKHRAllocator>>::type getCooperativeMatrixPropertiesKHR( CooperativeMatrixPropertiesKHRAllocator & cooperativeMatrixPropertiesKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12025 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12026
operator VkPhysicalDevice() const12027 operator VkPhysicalDevice() const VULKAN_HPP_NOEXCEPT
12028 {
12029 return m_physicalDevice;
12030 }
12031
operator bool() const12032 explicit operator bool() const VULKAN_HPP_NOEXCEPT
12033 {
12034 return m_physicalDevice != VK_NULL_HANDLE;
12035 }
12036
operator !() const12037 bool operator!() const VULKAN_HPP_NOEXCEPT
12038 {
12039 return m_physicalDevice == VK_NULL_HANDLE;
12040 }
12041
12042 private:
12043 VkPhysicalDevice m_physicalDevice = {};
12044 };
12045
12046 template <>
12047 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePhysicalDevice>
12048 {
12049 using Type = VULKAN_HPP_NAMESPACE::PhysicalDevice;
12050 };
12051
12052
12053 template <>
12054 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePhysicalDevice>
12055 {
12056 using Type = VULKAN_HPP_NAMESPACE::PhysicalDevice;
12057 };
12058
12059
12060 template <>
12061 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PhysicalDevice>
12062 {
12063 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
12064 };
12065
12066 class Instance
12067 {
12068 public:
12069 using CType = VkInstance;
12070 using NativeType = VkInstance;
12071
12072 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eInstance;
12073 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eInstance;
12074
12075 public:
12076 VULKAN_HPP_CONSTEXPR Instance() = default;
Instance(std::nullptr_t)12077 VULKAN_HPP_CONSTEXPR Instance( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
12078 {}
Instance(VkInstance instance)12079 Instance( VkInstance instance ) VULKAN_HPP_NOEXCEPT
12080 : m_instance( instance )
12081 {}
12082
operator =(VkInstance instance)12083 Instance & operator=(VkInstance instance) VULKAN_HPP_NOEXCEPT
12084 {
12085 m_instance = instance;
12086 return *this;
12087 }
12088
operator =(std::nullptr_t)12089 Instance & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
12090 {
12091 m_instance = {};
12092 return *this;
12093 }
12094
12095 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
12096 auto operator<=>( Instance const & ) const = default;
12097 #else
operator ==(Instance const & rhs) const12098 bool operator==( Instance const & rhs ) const VULKAN_HPP_NOEXCEPT
12099 {
12100 return m_instance == rhs.m_instance;
12101 }
12102
operator !=(Instance const & rhs) const12103 bool operator!=(Instance const & rhs ) const VULKAN_HPP_NOEXCEPT
12104 {
12105 return m_instance != rhs.m_instance;
12106 }
12107
operator <(Instance const & rhs) const12108 bool operator<(Instance const & rhs ) const VULKAN_HPP_NOEXCEPT
12109 {
12110 return m_instance < rhs.m_instance;
12111 }
12112 #endif
12113
12114 //=== VK_VERSION_1_0 ===
12115
12116
12117 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12118 void destroy( const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12119 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12120 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12121 void destroy( Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12122 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12123
12124
12125 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12126 VULKAN_HPP_NODISCARD Result enumeratePhysicalDevices( uint32_t * pPhysicalDeviceCount, VULKAN_HPP_NAMESPACE::PhysicalDevice * pPhysicalDevices, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12127 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12128 template <typename PhysicalDeviceAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDevice>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12129 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDevice, PhysicalDeviceAllocator>>::type enumeratePhysicalDevices( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12130 template <typename PhysicalDeviceAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDevice>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = PhysicalDeviceAllocator, typename std::enable_if<std::is_same<typename B1::value_type, PhysicalDevice>::value, int>::type = 0>
12131 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDevice, PhysicalDeviceAllocator>>::type enumeratePhysicalDevices( PhysicalDeviceAllocator & physicalDeviceAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12132 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12133
12134
12135 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12136 PFN_vkVoidFunction getProcAddr( const char * pName, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12137 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12138 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12139 PFN_vkVoidFunction getProcAddr( const std::string & name, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12140 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12141
12142 //=== VK_VERSION_1_1 ===
12143
12144
12145 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12146 VULKAN_HPP_NODISCARD Result enumeratePhysicalDeviceGroups( uint32_t * pPhysicalDeviceGroupCount, VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12147 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12148 template <typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12149 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type enumeratePhysicalDeviceGroups( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12150 template <typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = PhysicalDeviceGroupPropertiesAllocator, typename std::enable_if<std::is_same<typename B1::value_type, PhysicalDeviceGroupProperties>::value, int>::type = 0>
12151 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type enumeratePhysicalDeviceGroups( PhysicalDeviceGroupPropertiesAllocator & physicalDeviceGroupPropertiesAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12152 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12153
12154 //=== VK_KHR_surface ===
12155
12156
12157 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12158 void destroySurfaceKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12159 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12160 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12161 void destroySurfaceKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12162 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12163
12164
12165 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12166 void destroy( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12167 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12168 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12169 void destroy( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12170 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12171
12172 //=== VK_KHR_display ===
12173
12174
12175 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12176 VULKAN_HPP_NODISCARD Result createDisplayPlaneSurfaceKHR( const VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12177 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12178 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12179 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type createDisplayPlaneSurfaceKHR( const VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12180 # ifndef VULKAN_HPP_NO_SMART_HANDLE
12181 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12182 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type createDisplayPlaneSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12183 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
12184 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12185
12186 #if defined( VK_USE_PLATFORM_XLIB_KHR )
12187 //=== VK_KHR_xlib_surface ===
12188
12189
12190 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12191 VULKAN_HPP_NODISCARD Result createXlibSurfaceKHR( const VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12192 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12193 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12194 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type createXlibSurfaceKHR( const VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12195 # ifndef VULKAN_HPP_NO_SMART_HANDLE
12196 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12197 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type createXlibSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12198 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
12199 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12200 #endif /*VK_USE_PLATFORM_XLIB_KHR*/
12201
12202 #if defined( VK_USE_PLATFORM_XCB_KHR )
12203 //=== VK_KHR_xcb_surface ===
12204
12205
12206 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12207 VULKAN_HPP_NODISCARD Result createXcbSurfaceKHR( const VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12208 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12209 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12210 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type createXcbSurfaceKHR( const VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12211 # ifndef VULKAN_HPP_NO_SMART_HANDLE
12212 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12213 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type createXcbSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12214 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
12215 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12216 #endif /*VK_USE_PLATFORM_XCB_KHR*/
12217
12218 #if defined( VK_USE_PLATFORM_WAYLAND_KHR )
12219 //=== VK_KHR_wayland_surface ===
12220
12221
12222 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12223 VULKAN_HPP_NODISCARD Result createWaylandSurfaceKHR( const VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12224 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12225 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12226 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type createWaylandSurfaceKHR( const VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12227 # ifndef VULKAN_HPP_NO_SMART_HANDLE
12228 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12229 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type createWaylandSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12230 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
12231 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12232 #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
12233
12234 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
12235 //=== VK_KHR_android_surface ===
12236
12237
12238 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12239 VULKAN_HPP_NODISCARD Result createAndroidSurfaceKHR( const VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12240 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12241 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12242 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type createAndroidSurfaceKHR( const VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12243 # ifndef VULKAN_HPP_NO_SMART_HANDLE
12244 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12245 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type createAndroidSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12246 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
12247 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12248 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
12249
12250 #if defined( VK_USE_PLATFORM_WIN32_KHR )
12251 //=== VK_KHR_win32_surface ===
12252
12253
12254 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12255 VULKAN_HPP_NODISCARD Result createWin32SurfaceKHR( const VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12256 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12257 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12258 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type createWin32SurfaceKHR( const VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12259 # ifndef VULKAN_HPP_NO_SMART_HANDLE
12260 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12261 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type createWin32SurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12262 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
12263 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12264 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
12265
12266 //=== VK_EXT_debug_report ===
12267
12268
12269 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12270 VULKAN_HPP_NODISCARD Result createDebugReportCallbackEXT( const VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT * pCallback, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12271 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12272 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12273 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT>::type createDebugReportCallbackEXT( const VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12274 # ifndef VULKAN_HPP_NO_SMART_HANDLE
12275 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12276 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT, Dispatch>>::type createDebugReportCallbackEXTUnique( const VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12277 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
12278 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12279
12280
12281 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12282 void destroyDebugReportCallbackEXT( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12283 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12284 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12285 void destroyDebugReportCallbackEXT( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12286 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12287
12288
12289 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12290 void destroy( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12291 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12292 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12293 void destroy( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12294 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12295
12296
12297 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12298 void debugReportMessageEXT( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT flags, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType_, uint64_t object, size_t location, int32_t messageCode, const char * pLayerPrefix, const char * pMessage, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12299 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12300 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12301 void debugReportMessageEXT( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT flags, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType_, uint64_t object, size_t location, int32_t messageCode, const std::string & layerPrefix, const std::string & message, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12302 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12303
12304 #if defined( VK_USE_PLATFORM_GGP )
12305 //=== VK_GGP_stream_descriptor_surface ===
12306
12307
12308 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12309 VULKAN_HPP_NODISCARD Result createStreamDescriptorSurfaceGGP( const VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12310 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12311 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12312 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type createStreamDescriptorSurfaceGGP( const VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12313 # ifndef VULKAN_HPP_NO_SMART_HANDLE
12314 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12315 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type createStreamDescriptorSurfaceGGPUnique( const VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12316 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
12317 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12318 #endif /*VK_USE_PLATFORM_GGP*/
12319
12320 #if defined( VK_USE_PLATFORM_VI_NN )
12321 //=== VK_NN_vi_surface ===
12322
12323
12324 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12325 VULKAN_HPP_NODISCARD Result createViSurfaceNN( const VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12326 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12327 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12328 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type createViSurfaceNN( const VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12329 # ifndef VULKAN_HPP_NO_SMART_HANDLE
12330 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12331 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type createViSurfaceNNUnique( const VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12332 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
12333 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12334 #endif /*VK_USE_PLATFORM_VI_NN*/
12335
12336 //=== VK_KHR_device_group_creation ===
12337
12338
12339 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12340 VULKAN_HPP_NODISCARD Result enumeratePhysicalDeviceGroupsKHR( uint32_t * pPhysicalDeviceGroupCount, VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12341 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12342 template <typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12343 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type enumeratePhysicalDeviceGroupsKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12344 template <typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = PhysicalDeviceGroupPropertiesAllocator, typename std::enable_if<std::is_same<typename B1::value_type, PhysicalDeviceGroupProperties>::value, int>::type = 0>
12345 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type enumeratePhysicalDeviceGroupsKHR( PhysicalDeviceGroupPropertiesAllocator & physicalDeviceGroupPropertiesAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12346 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12347
12348 #if defined( VK_USE_PLATFORM_IOS_MVK )
12349 //=== VK_MVK_ios_surface ===
12350
12351
12352 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12353 VULKAN_HPP_NODISCARD Result createIOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12354 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12355 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12356 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type createIOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12357 # ifndef VULKAN_HPP_NO_SMART_HANDLE
12358 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12359 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type createIOSSurfaceMVKUnique( const VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12360 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
12361 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12362 #endif /*VK_USE_PLATFORM_IOS_MVK*/
12363
12364 #if defined( VK_USE_PLATFORM_MACOS_MVK )
12365 //=== VK_MVK_macos_surface ===
12366
12367
12368 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12369 VULKAN_HPP_NODISCARD Result createMacOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12370 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12371 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12372 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type createMacOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12373 # ifndef VULKAN_HPP_NO_SMART_HANDLE
12374 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12375 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type createMacOSSurfaceMVKUnique( const VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12376 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
12377 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12378 #endif /*VK_USE_PLATFORM_MACOS_MVK*/
12379
12380 //=== VK_EXT_debug_utils ===
12381
12382
12383 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12384 VULKAN_HPP_NODISCARD Result createDebugUtilsMessengerEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT * pMessenger, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12385 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12386 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12387 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT>::type createDebugUtilsMessengerEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12388 # ifndef VULKAN_HPP_NO_SMART_HANDLE
12389 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12390 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT, Dispatch>>::type createDebugUtilsMessengerEXTUnique( const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12391 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
12392 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12393
12394
12395 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12396 void destroyDebugUtilsMessengerEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12397 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12398 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12399 void destroyDebugUtilsMessengerEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12400 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12401
12402
12403 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12404 void destroy( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12405 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12406 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12407 void destroy( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12408 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12409
12410
12411 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12412 void submitDebugUtilsMessageEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT messageTypes, const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT * pCallbackData, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12413 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12414 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12415 void submitDebugUtilsMessageEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT messageTypes, const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT & callbackData, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12416 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12417
12418 #if defined( VK_USE_PLATFORM_FUCHSIA )
12419 //=== VK_FUCHSIA_imagepipe_surface ===
12420
12421
12422 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12423 VULKAN_HPP_NODISCARD Result createImagePipeSurfaceFUCHSIA( const VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12424 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12425 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12426 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type createImagePipeSurfaceFUCHSIA( const VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12427 # ifndef VULKAN_HPP_NO_SMART_HANDLE
12428 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12429 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type createImagePipeSurfaceFUCHSIAUnique( const VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12430 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
12431 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12432 #endif /*VK_USE_PLATFORM_FUCHSIA*/
12433
12434 #if defined( VK_USE_PLATFORM_METAL_EXT )
12435 //=== VK_EXT_metal_surface ===
12436
12437
12438 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12439 VULKAN_HPP_NODISCARD Result createMetalSurfaceEXT( const VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12440 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12441 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12442 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type createMetalSurfaceEXT( const VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12443 # ifndef VULKAN_HPP_NO_SMART_HANDLE
12444 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12445 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type createMetalSurfaceEXTUnique( const VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12446 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
12447 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12448 #endif /*VK_USE_PLATFORM_METAL_EXT*/
12449
12450 //=== VK_EXT_headless_surface ===
12451
12452
12453 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12454 VULKAN_HPP_NODISCARD Result createHeadlessSurfaceEXT( const VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12455 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12456 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12457 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type createHeadlessSurfaceEXT( const VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12458 # ifndef VULKAN_HPP_NO_SMART_HANDLE
12459 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12460 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type createHeadlessSurfaceEXTUnique( const VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12461 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
12462 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12463
12464 #if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
12465 //=== VK_EXT_directfb_surface ===
12466
12467
12468 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12469 VULKAN_HPP_NODISCARD Result createDirectFBSurfaceEXT( const VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12470 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12471 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12472 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type createDirectFBSurfaceEXT( const VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12473 # ifndef VULKAN_HPP_NO_SMART_HANDLE
12474 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12475 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type createDirectFBSurfaceEXTUnique( const VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12476 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
12477 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12478 #endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
12479
12480 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
12481 //=== VK_QNX_screen_surface ===
12482
12483
12484 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12485 VULKAN_HPP_NODISCARD Result createScreenSurfaceQNX( const VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12486 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12487 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12488 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type createScreenSurfaceQNX( const VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12489 # ifndef VULKAN_HPP_NO_SMART_HANDLE
12490 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12491 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type createScreenSurfaceQNXUnique( const VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12492 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
12493 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12494 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
12495
operator VkInstance() const12496 operator VkInstance() const VULKAN_HPP_NOEXCEPT
12497 {
12498 return m_instance;
12499 }
12500
operator bool() const12501 explicit operator bool() const VULKAN_HPP_NOEXCEPT
12502 {
12503 return m_instance != VK_NULL_HANDLE;
12504 }
12505
operator !() const12506 bool operator!() const VULKAN_HPP_NOEXCEPT
12507 {
12508 return m_instance == VK_NULL_HANDLE;
12509 }
12510
12511 private:
12512 VkInstance m_instance = {};
12513 };
12514
12515 template <>
12516 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eInstance>
12517 {
12518 using Type = VULKAN_HPP_NAMESPACE::Instance;
12519 };
12520
12521
12522 template <>
12523 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eInstance>
12524 {
12525 using Type = VULKAN_HPP_NAMESPACE::Instance;
12526 };
12527
12528
12529 template <>
12530 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Instance>
12531 {
12532 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
12533 };
12534
12535 //=== VK_VERSION_1_0 ===
12536
12537
12538 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12539 VULKAN_HPP_NODISCARD Result createInstance( const VULKAN_HPP_NAMESPACE::InstanceCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::Instance * pInstance, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT;
12540 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12541 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12542 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Instance>::type createInstance( const VULKAN_HPP_NAMESPACE::InstanceCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
12543 # ifndef VULKAN_HPP_NO_SMART_HANDLE
12544 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12545 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Instance, Dispatch>>::type createInstanceUnique( const VULKAN_HPP_NAMESPACE::InstanceCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
12546 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
12547 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12548
12549
12550 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12551 VULKAN_HPP_NODISCARD Result enumerateInstanceExtensionProperties( const char * pLayerName, uint32_t * pPropertyCount, VULKAN_HPP_NAMESPACE::ExtensionProperties * pProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT;
12552 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12553 template <typename ExtensionPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::ExtensionProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12554 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties, ExtensionPropertiesAllocator>>::type enumerateInstanceExtensionProperties( Optional<const std::string> layerName VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
12555 template <typename ExtensionPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::ExtensionProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = ExtensionPropertiesAllocator, typename std::enable_if<std::is_same<typename B1::value_type, ExtensionProperties>::value, int>::type = 0>
12556 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties, ExtensionPropertiesAllocator>>::type enumerateInstanceExtensionProperties( Optional<const std::string> layerName, ExtensionPropertiesAllocator & extensionPropertiesAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
12557 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12558
12559
12560 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12561 VULKAN_HPP_NODISCARD Result enumerateInstanceLayerProperties( uint32_t * pPropertyCount, VULKAN_HPP_NAMESPACE::LayerProperties * pProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT;
12562 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12563 template <typename LayerPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::LayerProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12564 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::LayerProperties, LayerPropertiesAllocator>>::type enumerateInstanceLayerProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
12565 template <typename LayerPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::LayerProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = LayerPropertiesAllocator, typename std::enable_if<std::is_same<typename B1::value_type, LayerProperties>::value, int>::type = 0>
12566 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::LayerProperties, LayerPropertiesAllocator>>::type enumerateInstanceLayerProperties( LayerPropertiesAllocator & layerPropertiesAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
12567 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12568
12569 //=== VK_VERSION_1_1 ===
12570
12571
12572 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12573 VULKAN_HPP_NODISCARD Result enumerateInstanceVersion( uint32_t * pApiVersion, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT;
12574 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12575 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12576 VULKAN_HPP_NODISCARD typename ResultValueType<uint32_t>::type enumerateInstanceVersion( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
12577 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12578
12579 } // namespace VULKAN_HPP_NAMESPACE
12580
12581 // operators to compare vk::-handles with nullptr
12582 template <typename T>
operator ==(const T & v,std::nullptr_t)12583 typename std::enable_if<VULKAN_HPP_NAMESPACE::isVulkanHandleType<T>::value, bool>::type operator==( const T & v, std::nullptr_t )
12584 {
12585 return !v;
12586 }
12587
12588 template <typename T>
operator ==(std::nullptr_t,const T & v)12589 typename std::enable_if<VULKAN_HPP_NAMESPACE::isVulkanHandleType<T>::value, bool>::type operator==( std::nullptr_t, const T & v )
12590 {
12591 return !v;
12592 }
12593
12594 template <typename T>
operator !=(const T & v,std::nullptr_t)12595 typename std::enable_if<VULKAN_HPP_NAMESPACE::isVulkanHandleType<T>::value, bool>::type operator!=( const T & v, std::nullptr_t )
12596 {
12597 return v;
12598 }
12599
12600 template <typename T>
operator !=(std::nullptr_t,const T & v)12601 typename std::enable_if<VULKAN_HPP_NAMESPACE::isVulkanHandleType<T>::value, bool>::type operator!=( std::nullptr_t, const T & v )
12602 {
12603 return v;
12604 }
12605 #endif
12606