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 ImageSubresource;
56 struct FenceCreateInfo;
57 struct SemaphoreCreateInfo;
58 struct EventCreateInfo;
59 struct QueryPoolCreateInfo;
60 struct BufferCreateInfo;
61 struct BufferViewCreateInfo;
62 struct ImageCreateInfo;
63 struct SubresourceLayout;
64 struct ComponentMapping;
65 struct ImageSubresourceRange;
66 struct ImageViewCreateInfo;
67 struct PipelineCacheCreateInfo;
68 struct ComputePipelineCreateInfo;
69 struct GraphicsPipelineCreateInfo;
70 struct PipelineColorBlendAttachmentState;
71 struct PipelineColorBlendStateCreateInfo;
72 struct PipelineDepthStencilStateCreateInfo;
73 struct PipelineDynamicStateCreateInfo;
74 struct PipelineInputAssemblyStateCreateInfo;
75 struct PipelineMultisampleStateCreateInfo;
76 struct PipelineRasterizationStateCreateInfo;
77 struct PipelineShaderStageCreateInfo;
78 struct PipelineTessellationStateCreateInfo;
79 struct PipelineVertexInputStateCreateInfo;
80 struct PipelineViewportStateCreateInfo;
81 struct SpecializationInfo;
82 struct SpecializationMapEntry;
83 struct StencilOpState;
84 struct VertexInputAttributeDescription;
85 struct VertexInputBindingDescription;
86 struct Viewport;
87 struct PipelineLayoutCreateInfo;
88 struct PushConstantRange;
89 struct SamplerCreateInfo;
90 struct CopyDescriptorSet;
91 struct DescriptorBufferInfo;
92 struct DescriptorImageInfo;
93 struct DescriptorPoolCreateInfo;
94 struct DescriptorPoolSize;
95 struct DescriptorSetAllocateInfo;
96 struct DescriptorSetLayoutBinding;
97 struct DescriptorSetLayoutCreateInfo;
98 struct WriteDescriptorSet;
99 struct AttachmentDescription;
100 struct AttachmentReference;
101 struct FramebufferCreateInfo;
102 struct RenderPassCreateInfo;
103 struct SubpassDependency;
104 struct SubpassDescription;
105 struct CommandPoolCreateInfo;
106 struct CommandBufferAllocateInfo;
107 struct CommandBufferBeginInfo;
108 struct CommandBufferInheritanceInfo;
109 struct BufferCopy;
110 struct BufferImageCopy;
111 struct ClearAttachment;
112 union ClearColorValue;
113 struct ClearDepthStencilValue;
114 struct ClearRect;
115 union ClearValue;
116 struct ImageBlit;
117 struct ImageCopy;
118 struct ImageResolve;
119 struct ImageSubresourceLayers;
120 struct RenderPassBeginInfo;
121
122 //=== VK_VERSION_1_1 ===
123 struct PhysicalDeviceSubgroupProperties;
124 struct BindBufferMemoryInfo;
125 using BindBufferMemoryInfoKHR = BindBufferMemoryInfo;
126 struct BindImageMemoryInfo;
127 using BindImageMemoryInfoKHR = BindImageMemoryInfo;
128 struct PhysicalDevice16BitStorageFeatures;
129 using PhysicalDevice16BitStorageFeaturesKHR = PhysicalDevice16BitStorageFeatures;
130 struct MemoryDedicatedRequirements;
131 using MemoryDedicatedRequirementsKHR = MemoryDedicatedRequirements;
132 struct MemoryDedicatedAllocateInfo;
133 using MemoryDedicatedAllocateInfoKHR = MemoryDedicatedAllocateInfo;
134 struct MemoryAllocateFlagsInfo;
135 using MemoryAllocateFlagsInfoKHR = MemoryAllocateFlagsInfo;
136 struct DeviceGroupRenderPassBeginInfo;
137 using DeviceGroupRenderPassBeginInfoKHR = DeviceGroupRenderPassBeginInfo;
138 struct DeviceGroupCommandBufferBeginInfo;
139 using DeviceGroupCommandBufferBeginInfoKHR = DeviceGroupCommandBufferBeginInfo;
140 struct DeviceGroupSubmitInfo;
141 using DeviceGroupSubmitInfoKHR = DeviceGroupSubmitInfo;
142 struct BindBufferMemoryDeviceGroupInfo;
143 using BindBufferMemoryDeviceGroupInfoKHR = BindBufferMemoryDeviceGroupInfo;
144 struct BindImageMemoryDeviceGroupInfo;
145 using BindImageMemoryDeviceGroupInfoKHR = BindImageMemoryDeviceGroupInfo;
146 struct PhysicalDeviceGroupProperties;
147 using PhysicalDeviceGroupPropertiesKHR = PhysicalDeviceGroupProperties;
148 struct DeviceGroupDeviceCreateInfo;
149 using DeviceGroupDeviceCreateInfoKHR = DeviceGroupDeviceCreateInfo;
150 struct BufferMemoryRequirementsInfo2;
151 using BufferMemoryRequirementsInfo2KHR = BufferMemoryRequirementsInfo2;
152 struct ImageMemoryRequirementsInfo2;
153 using ImageMemoryRequirementsInfo2KHR = ImageMemoryRequirementsInfo2;
154 struct MemoryRequirements2;
155 using MemoryRequirements2KHR = MemoryRequirements2;
156 struct PhysicalDeviceFeatures2;
157 using PhysicalDeviceFeatures2KHR = PhysicalDeviceFeatures2;
158 struct PhysicalDeviceProperties2;
159 using PhysicalDeviceProperties2KHR = PhysicalDeviceProperties2;
160 struct FormatProperties2;
161 using FormatProperties2KHR = FormatProperties2;
162 struct ImageFormatProperties2;
163 using ImageFormatProperties2KHR = ImageFormatProperties2;
164 struct PhysicalDeviceImageFormatInfo2;
165 using PhysicalDeviceImageFormatInfo2KHR = PhysicalDeviceImageFormatInfo2;
166 struct QueueFamilyProperties2;
167 using QueueFamilyProperties2KHR = QueueFamilyProperties2;
168 struct PhysicalDeviceMemoryProperties2;
169 using PhysicalDeviceMemoryProperties2KHR = PhysicalDeviceMemoryProperties2;
170 struct PhysicalDevicePointClippingProperties;
171 using PhysicalDevicePointClippingPropertiesKHR = PhysicalDevicePointClippingProperties;
172 struct RenderPassInputAttachmentAspectCreateInfo;
173 using RenderPassInputAttachmentAspectCreateInfoKHR = RenderPassInputAttachmentAspectCreateInfo;
174 struct InputAttachmentAspectReference;
175 using InputAttachmentAspectReferenceKHR = InputAttachmentAspectReference;
176 struct ImageViewUsageCreateInfo;
177 using ImageViewUsageCreateInfoKHR = ImageViewUsageCreateInfo;
178 struct PipelineTessellationDomainOriginStateCreateInfo;
179 using PipelineTessellationDomainOriginStateCreateInfoKHR = PipelineTessellationDomainOriginStateCreateInfo;
180 struct RenderPassMultiviewCreateInfo;
181 using RenderPassMultiviewCreateInfoKHR = RenderPassMultiviewCreateInfo;
182 struct PhysicalDeviceMultiviewFeatures;
183 using PhysicalDeviceMultiviewFeaturesKHR = PhysicalDeviceMultiviewFeatures;
184 struct PhysicalDeviceMultiviewProperties;
185 using PhysicalDeviceMultiviewPropertiesKHR = PhysicalDeviceMultiviewProperties;
186 struct PhysicalDeviceVariablePointersFeatures;
187 using PhysicalDeviceVariablePointerFeatures = PhysicalDeviceVariablePointersFeatures;
188 using PhysicalDeviceVariablePointerFeaturesKHR = PhysicalDeviceVariablePointersFeatures;
189 using PhysicalDeviceVariablePointersFeaturesKHR = PhysicalDeviceVariablePointersFeatures;
190 struct PhysicalDeviceProtectedMemoryFeatures;
191 struct PhysicalDeviceProtectedMemoryProperties;
192 struct DeviceQueueInfo2;
193 struct ProtectedSubmitInfo;
194 struct SamplerYcbcrConversionCreateInfo;
195 using SamplerYcbcrConversionCreateInfoKHR = SamplerYcbcrConversionCreateInfo;
196 struct SamplerYcbcrConversionInfo;
197 using SamplerYcbcrConversionInfoKHR = SamplerYcbcrConversionInfo;
198 struct BindImagePlaneMemoryInfo;
199 using BindImagePlaneMemoryInfoKHR = BindImagePlaneMemoryInfo;
200 struct ImagePlaneMemoryRequirementsInfo;
201 using ImagePlaneMemoryRequirementsInfoKHR = ImagePlaneMemoryRequirementsInfo;
202 struct PhysicalDeviceSamplerYcbcrConversionFeatures;
203 using PhysicalDeviceSamplerYcbcrConversionFeaturesKHR = PhysicalDeviceSamplerYcbcrConversionFeatures;
204 struct SamplerYcbcrConversionImageFormatProperties;
205 using SamplerYcbcrConversionImageFormatPropertiesKHR = SamplerYcbcrConversionImageFormatProperties;
206 struct ExternalMemoryProperties;
207 using ExternalMemoryPropertiesKHR = ExternalMemoryProperties;
208 struct PhysicalDeviceExternalImageFormatInfo;
209 using PhysicalDeviceExternalImageFormatInfoKHR = PhysicalDeviceExternalImageFormatInfo;
210 struct ExternalImageFormatProperties;
211 using ExternalImageFormatPropertiesKHR = ExternalImageFormatProperties;
212 struct PhysicalDeviceExternalBufferInfo;
213 using PhysicalDeviceExternalBufferInfoKHR = PhysicalDeviceExternalBufferInfo;
214 struct ExternalBufferProperties;
215 using ExternalBufferPropertiesKHR = ExternalBufferProperties;
216 struct PhysicalDeviceIDProperties;
217 using PhysicalDeviceIDPropertiesKHR = PhysicalDeviceIDProperties;
218 struct ExternalMemoryImageCreateInfo;
219 using ExternalMemoryImageCreateInfoKHR = ExternalMemoryImageCreateInfo;
220 struct ExternalMemoryBufferCreateInfo;
221 using ExternalMemoryBufferCreateInfoKHR = ExternalMemoryBufferCreateInfo;
222 struct ExportMemoryAllocateInfo;
223 using ExportMemoryAllocateInfoKHR = ExportMemoryAllocateInfo;
224 struct PhysicalDeviceExternalFenceInfo;
225 using PhysicalDeviceExternalFenceInfoKHR = PhysicalDeviceExternalFenceInfo;
226 struct ExternalFenceProperties;
227 using ExternalFencePropertiesKHR = ExternalFenceProperties;
228 struct ExportFenceCreateInfo;
229 using ExportFenceCreateInfoKHR = ExportFenceCreateInfo;
230 struct ExportSemaphoreCreateInfo;
231 using ExportSemaphoreCreateInfoKHR = ExportSemaphoreCreateInfo;
232 struct PhysicalDeviceExternalSemaphoreInfo;
233 using PhysicalDeviceExternalSemaphoreInfoKHR = PhysicalDeviceExternalSemaphoreInfo;
234 struct ExternalSemaphoreProperties;
235 using ExternalSemaphorePropertiesKHR = ExternalSemaphoreProperties;
236 struct PhysicalDeviceMaintenance3Properties;
237 using PhysicalDeviceMaintenance3PropertiesKHR = PhysicalDeviceMaintenance3Properties;
238 struct DescriptorSetLayoutSupport;
239 using DescriptorSetLayoutSupportKHR = DescriptorSetLayoutSupport;
240 struct PhysicalDeviceShaderDrawParametersFeatures;
241 using PhysicalDeviceShaderDrawParameterFeatures = PhysicalDeviceShaderDrawParametersFeatures;
242
243 //=== VK_VERSION_1_2 ===
244 struct PhysicalDeviceVulkan11Features;
245 struct PhysicalDeviceVulkan11Properties;
246 struct PhysicalDeviceVulkan12Features;
247 struct PhysicalDeviceVulkan12Properties;
248 struct ImageFormatListCreateInfo;
249 using ImageFormatListCreateInfoKHR = ImageFormatListCreateInfo;
250 struct RenderPassCreateInfo2;
251 using RenderPassCreateInfo2KHR = RenderPassCreateInfo2;
252 struct AttachmentDescription2;
253 using AttachmentDescription2KHR = AttachmentDescription2;
254 struct AttachmentReference2;
255 using AttachmentReference2KHR = AttachmentReference2;
256 struct SubpassDescription2;
257 using SubpassDescription2KHR = SubpassDescription2;
258 struct SubpassDependency2;
259 using SubpassDependency2KHR = SubpassDependency2;
260 struct SubpassBeginInfo;
261 using SubpassBeginInfoKHR = SubpassBeginInfo;
262 struct SubpassEndInfo;
263 using SubpassEndInfoKHR = SubpassEndInfo;
264 struct PhysicalDevice8BitStorageFeatures;
265 using PhysicalDevice8BitStorageFeaturesKHR = PhysicalDevice8BitStorageFeatures;
266 struct ConformanceVersion;
267 using ConformanceVersionKHR = ConformanceVersion;
268 struct PhysicalDeviceDriverProperties;
269 using PhysicalDeviceDriverPropertiesKHR = PhysicalDeviceDriverProperties;
270 struct PhysicalDeviceShaderAtomicInt64Features;
271 using PhysicalDeviceShaderAtomicInt64FeaturesKHR = PhysicalDeviceShaderAtomicInt64Features;
272 struct PhysicalDeviceShaderFloat16Int8Features;
273 using PhysicalDeviceFloat16Int8FeaturesKHR = PhysicalDeviceShaderFloat16Int8Features;
274 using PhysicalDeviceShaderFloat16Int8FeaturesKHR = PhysicalDeviceShaderFloat16Int8Features;
275 struct PhysicalDeviceFloatControlsProperties;
276 using PhysicalDeviceFloatControlsPropertiesKHR = PhysicalDeviceFloatControlsProperties;
277 struct DescriptorSetLayoutBindingFlagsCreateInfo;
278 using DescriptorSetLayoutBindingFlagsCreateInfoEXT = DescriptorSetLayoutBindingFlagsCreateInfo;
279 struct PhysicalDeviceDescriptorIndexingFeatures;
280 using PhysicalDeviceDescriptorIndexingFeaturesEXT = PhysicalDeviceDescriptorIndexingFeatures;
281 struct PhysicalDeviceDescriptorIndexingProperties;
282 using PhysicalDeviceDescriptorIndexingPropertiesEXT = PhysicalDeviceDescriptorIndexingProperties;
283 struct DescriptorSetVariableDescriptorCountAllocateInfo;
284 using DescriptorSetVariableDescriptorCountAllocateInfoEXT = DescriptorSetVariableDescriptorCountAllocateInfo;
285 struct DescriptorSetVariableDescriptorCountLayoutSupport;
286 using DescriptorSetVariableDescriptorCountLayoutSupportEXT = DescriptorSetVariableDescriptorCountLayoutSupport;
287 struct SubpassDescriptionDepthStencilResolve;
288 using SubpassDescriptionDepthStencilResolveKHR = SubpassDescriptionDepthStencilResolve;
289 struct PhysicalDeviceDepthStencilResolveProperties;
290 using PhysicalDeviceDepthStencilResolvePropertiesKHR = PhysicalDeviceDepthStencilResolveProperties;
291 struct PhysicalDeviceScalarBlockLayoutFeatures;
292 using PhysicalDeviceScalarBlockLayoutFeaturesEXT = PhysicalDeviceScalarBlockLayoutFeatures;
293 struct ImageStencilUsageCreateInfo;
294 using ImageStencilUsageCreateInfoEXT = ImageStencilUsageCreateInfo;
295 struct SamplerReductionModeCreateInfo;
296 using SamplerReductionModeCreateInfoEXT = SamplerReductionModeCreateInfo;
297 struct PhysicalDeviceSamplerFilterMinmaxProperties;
298 using PhysicalDeviceSamplerFilterMinmaxPropertiesEXT = PhysicalDeviceSamplerFilterMinmaxProperties;
299 struct PhysicalDeviceVulkanMemoryModelFeatures;
300 using PhysicalDeviceVulkanMemoryModelFeaturesKHR = PhysicalDeviceVulkanMemoryModelFeatures;
301 struct PhysicalDeviceImagelessFramebufferFeatures;
302 using PhysicalDeviceImagelessFramebufferFeaturesKHR = PhysicalDeviceImagelessFramebufferFeatures;
303 struct FramebufferAttachmentsCreateInfo;
304 using FramebufferAttachmentsCreateInfoKHR = FramebufferAttachmentsCreateInfo;
305 struct FramebufferAttachmentImageInfo;
306 using FramebufferAttachmentImageInfoKHR = FramebufferAttachmentImageInfo;
307 struct RenderPassAttachmentBeginInfo;
308 using RenderPassAttachmentBeginInfoKHR = RenderPassAttachmentBeginInfo;
309 struct PhysicalDeviceUniformBufferStandardLayoutFeatures;
310 using PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR = PhysicalDeviceUniformBufferStandardLayoutFeatures;
311 struct PhysicalDeviceShaderSubgroupExtendedTypesFeatures;
312 using PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR = PhysicalDeviceShaderSubgroupExtendedTypesFeatures;
313 struct PhysicalDeviceSeparateDepthStencilLayoutsFeatures;
314 using PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR = PhysicalDeviceSeparateDepthStencilLayoutsFeatures;
315 struct AttachmentReferenceStencilLayout;
316 using AttachmentReferenceStencilLayoutKHR = AttachmentReferenceStencilLayout;
317 struct AttachmentDescriptionStencilLayout;
318 using AttachmentDescriptionStencilLayoutKHR = AttachmentDescriptionStencilLayout;
319 struct PhysicalDeviceHostQueryResetFeatures;
320 using PhysicalDeviceHostQueryResetFeaturesEXT = PhysicalDeviceHostQueryResetFeatures;
321 struct PhysicalDeviceTimelineSemaphoreFeatures;
322 using PhysicalDeviceTimelineSemaphoreFeaturesKHR = PhysicalDeviceTimelineSemaphoreFeatures;
323 struct PhysicalDeviceTimelineSemaphoreProperties;
324 using PhysicalDeviceTimelineSemaphorePropertiesKHR = PhysicalDeviceTimelineSemaphoreProperties;
325 struct SemaphoreTypeCreateInfo;
326 using SemaphoreTypeCreateInfoKHR = SemaphoreTypeCreateInfo;
327 struct TimelineSemaphoreSubmitInfo;
328 using TimelineSemaphoreSubmitInfoKHR = TimelineSemaphoreSubmitInfo;
329 struct SemaphoreWaitInfo;
330 using SemaphoreWaitInfoKHR = SemaphoreWaitInfo;
331 struct SemaphoreSignalInfo;
332 using SemaphoreSignalInfoKHR = SemaphoreSignalInfo;
333 struct PhysicalDeviceBufferDeviceAddressFeatures;
334 using PhysicalDeviceBufferDeviceAddressFeaturesKHR = PhysicalDeviceBufferDeviceAddressFeatures;
335 struct BufferDeviceAddressInfo;
336 using BufferDeviceAddressInfoEXT = BufferDeviceAddressInfo;
337 using BufferDeviceAddressInfoKHR = BufferDeviceAddressInfo;
338 struct BufferOpaqueCaptureAddressCreateInfo;
339 using BufferOpaqueCaptureAddressCreateInfoKHR = BufferOpaqueCaptureAddressCreateInfo;
340 struct MemoryOpaqueCaptureAddressAllocateInfo;
341 using MemoryOpaqueCaptureAddressAllocateInfoKHR = MemoryOpaqueCaptureAddressAllocateInfo;
342 struct DeviceMemoryOpaqueCaptureAddressInfo;
343 using DeviceMemoryOpaqueCaptureAddressInfoKHR = DeviceMemoryOpaqueCaptureAddressInfo;
344
345 //=== VK_VERSION_1_3 ===
346 struct PhysicalDeviceVulkan13Features;
347 struct PhysicalDeviceVulkan13Properties;
348 struct PipelineCreationFeedbackCreateInfo;
349 using PipelineCreationFeedbackCreateInfoEXT = PipelineCreationFeedbackCreateInfo;
350 struct PipelineCreationFeedback;
351 using PipelineCreationFeedbackEXT = PipelineCreationFeedback;
352 struct PhysicalDeviceShaderTerminateInvocationFeatures;
353 using PhysicalDeviceShaderTerminateInvocationFeaturesKHR = PhysicalDeviceShaderTerminateInvocationFeatures;
354 struct PhysicalDeviceToolProperties;
355 using PhysicalDeviceToolPropertiesEXT = PhysicalDeviceToolProperties;
356 struct PhysicalDeviceShaderDemoteToHelperInvocationFeatures;
357 using PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT = PhysicalDeviceShaderDemoteToHelperInvocationFeatures;
358 struct PhysicalDevicePrivateDataFeatures;
359 using PhysicalDevicePrivateDataFeaturesEXT = PhysicalDevicePrivateDataFeatures;
360 struct DevicePrivateDataCreateInfo;
361 using DevicePrivateDataCreateInfoEXT = DevicePrivateDataCreateInfo;
362 struct PrivateDataSlotCreateInfo;
363 using PrivateDataSlotCreateInfoEXT = PrivateDataSlotCreateInfo;
364 struct PhysicalDevicePipelineCreationCacheControlFeatures;
365 using PhysicalDevicePipelineCreationCacheControlFeaturesEXT = PhysicalDevicePipelineCreationCacheControlFeatures;
366 struct MemoryBarrier2;
367 using MemoryBarrier2KHR = MemoryBarrier2;
368 struct BufferMemoryBarrier2;
369 using BufferMemoryBarrier2KHR = BufferMemoryBarrier2;
370 struct ImageMemoryBarrier2;
371 using ImageMemoryBarrier2KHR = ImageMemoryBarrier2;
372 struct DependencyInfo;
373 using DependencyInfoKHR = DependencyInfo;
374 struct SubmitInfo2;
375 using SubmitInfo2KHR = SubmitInfo2;
376 struct SemaphoreSubmitInfo;
377 using SemaphoreSubmitInfoKHR = SemaphoreSubmitInfo;
378 struct CommandBufferSubmitInfo;
379 using CommandBufferSubmitInfoKHR = CommandBufferSubmitInfo;
380 struct PhysicalDeviceSynchronization2Features;
381 using PhysicalDeviceSynchronization2FeaturesKHR = PhysicalDeviceSynchronization2Features;
382 struct PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures;
383 using PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR = PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures;
384 struct PhysicalDeviceImageRobustnessFeatures;
385 using PhysicalDeviceImageRobustnessFeaturesEXT = PhysicalDeviceImageRobustnessFeatures;
386 struct CopyBufferInfo2;
387 using CopyBufferInfo2KHR = CopyBufferInfo2;
388 struct CopyImageInfo2;
389 using CopyImageInfo2KHR = CopyImageInfo2;
390 struct CopyBufferToImageInfo2;
391 using CopyBufferToImageInfo2KHR = CopyBufferToImageInfo2;
392 struct CopyImageToBufferInfo2;
393 using CopyImageToBufferInfo2KHR = CopyImageToBufferInfo2;
394 struct BlitImageInfo2;
395 using BlitImageInfo2KHR = BlitImageInfo2;
396 struct ResolveImageInfo2;
397 using ResolveImageInfo2KHR = ResolveImageInfo2;
398 struct BufferCopy2;
399 using BufferCopy2KHR = BufferCopy2;
400 struct ImageCopy2;
401 using ImageCopy2KHR = ImageCopy2;
402 struct ImageBlit2;
403 using ImageBlit2KHR = ImageBlit2;
404 struct BufferImageCopy2;
405 using BufferImageCopy2KHR = BufferImageCopy2;
406 struct ImageResolve2;
407 using ImageResolve2KHR = ImageResolve2;
408 struct PhysicalDeviceSubgroupSizeControlFeatures;
409 using PhysicalDeviceSubgroupSizeControlFeaturesEXT = PhysicalDeviceSubgroupSizeControlFeatures;
410 struct PhysicalDeviceSubgroupSizeControlProperties;
411 using PhysicalDeviceSubgroupSizeControlPropertiesEXT = PhysicalDeviceSubgroupSizeControlProperties;
412 struct PipelineShaderStageRequiredSubgroupSizeCreateInfo;
413 using PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT = PipelineShaderStageRequiredSubgroupSizeCreateInfo;
414 using ShaderRequiredSubgroupSizeCreateInfoEXT = PipelineShaderStageRequiredSubgroupSizeCreateInfo;
415 struct PhysicalDeviceInlineUniformBlockFeatures;
416 using PhysicalDeviceInlineUniformBlockFeaturesEXT = PhysicalDeviceInlineUniformBlockFeatures;
417 struct PhysicalDeviceInlineUniformBlockProperties;
418 using PhysicalDeviceInlineUniformBlockPropertiesEXT = PhysicalDeviceInlineUniformBlockProperties;
419 struct WriteDescriptorSetInlineUniformBlock;
420 using WriteDescriptorSetInlineUniformBlockEXT = WriteDescriptorSetInlineUniformBlock;
421 struct DescriptorPoolInlineUniformBlockCreateInfo;
422 using DescriptorPoolInlineUniformBlockCreateInfoEXT = DescriptorPoolInlineUniformBlockCreateInfo;
423 struct PhysicalDeviceTextureCompressionASTCHDRFeatures;
424 using PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT = PhysicalDeviceTextureCompressionASTCHDRFeatures;
425 struct RenderingInfo;
426 using RenderingInfoKHR = RenderingInfo;
427 struct RenderingAttachmentInfo;
428 using RenderingAttachmentInfoKHR = RenderingAttachmentInfo;
429 struct PipelineRenderingCreateInfo;
430 using PipelineRenderingCreateInfoKHR = PipelineRenderingCreateInfo;
431 struct PhysicalDeviceDynamicRenderingFeatures;
432 using PhysicalDeviceDynamicRenderingFeaturesKHR = PhysicalDeviceDynamicRenderingFeatures;
433 struct CommandBufferInheritanceRenderingInfo;
434 using CommandBufferInheritanceRenderingInfoKHR = CommandBufferInheritanceRenderingInfo;
435 struct PhysicalDeviceShaderIntegerDotProductFeatures;
436 using PhysicalDeviceShaderIntegerDotProductFeaturesKHR = PhysicalDeviceShaderIntegerDotProductFeatures;
437 struct PhysicalDeviceShaderIntegerDotProductProperties;
438 using PhysicalDeviceShaderIntegerDotProductPropertiesKHR = PhysicalDeviceShaderIntegerDotProductProperties;
439 struct PhysicalDeviceTexelBufferAlignmentProperties;
440 using PhysicalDeviceTexelBufferAlignmentPropertiesEXT = PhysicalDeviceTexelBufferAlignmentProperties;
441 struct FormatProperties3;
442 using FormatProperties3KHR = FormatProperties3;
443 struct PhysicalDeviceMaintenance4Features;
444 using PhysicalDeviceMaintenance4FeaturesKHR = PhysicalDeviceMaintenance4Features;
445 struct PhysicalDeviceMaintenance4Properties;
446 using PhysicalDeviceMaintenance4PropertiesKHR = PhysicalDeviceMaintenance4Properties;
447 struct DeviceBufferMemoryRequirements;
448 using DeviceBufferMemoryRequirementsKHR = DeviceBufferMemoryRequirements;
449 struct DeviceImageMemoryRequirements;
450 using DeviceImageMemoryRequirementsKHR = DeviceImageMemoryRequirements;
451
452 //=== VKSC_VERSION_1_0 ===
453 struct PhysicalDeviceVulkanSC10Features;
454 struct PhysicalDeviceVulkanSC10Properties;
455 struct DeviceObjectReservationCreateInfo;
456 struct CommandPoolMemoryReservationCreateInfo;
457 struct CommandPoolMemoryConsumption;
458 struct PipelinePoolSize;
459 struct FaultData;
460 struct FaultCallbackInfo;
461 struct PipelineOfflineCreateInfo;
462 struct PipelineCacheStageValidationIndexEntry;
463 struct PipelineCacheSafetyCriticalIndexEntry;
464 struct PipelineCacheHeaderVersionSafetyCriticalOne;
465
466 //=== VK_KHR_surface ===
467 struct SurfaceCapabilitiesKHR;
468 struct SurfaceFormatKHR;
469
470 //=== VK_KHR_swapchain ===
471 struct SwapchainCreateInfoKHR;
472 struct PresentInfoKHR;
473 struct ImageSwapchainCreateInfoKHR;
474 struct BindImageMemorySwapchainInfoKHR;
475 struct AcquireNextImageInfoKHR;
476 struct DeviceGroupPresentCapabilitiesKHR;
477 struct DeviceGroupPresentInfoKHR;
478 struct DeviceGroupSwapchainCreateInfoKHR;
479
480 //=== VK_KHR_display ===
481 struct DisplayModeCreateInfoKHR;
482 struct DisplayModeParametersKHR;
483 struct DisplayModePropertiesKHR;
484 struct DisplayPlaneCapabilitiesKHR;
485 struct DisplayPlanePropertiesKHR;
486 struct DisplayPropertiesKHR;
487 struct DisplaySurfaceCreateInfoKHR;
488
489 //=== VK_KHR_display_swapchain ===
490 struct DisplayPresentInfoKHR;
491
492 //=== VK_EXT_astc_decode_mode ===
493 struct ImageViewASTCDecodeModeEXT;
494 struct PhysicalDeviceASTCDecodeFeaturesEXT;
495
496 //=== VK_KHR_external_memory_fd ===
497 struct ImportMemoryFdInfoKHR;
498 struct MemoryFdPropertiesKHR;
499 struct MemoryGetFdInfoKHR;
500
501 //=== VK_KHR_external_semaphore_fd ===
502 struct ImportSemaphoreFdInfoKHR;
503 struct SemaphoreGetFdInfoKHR;
504
505 //=== VK_KHR_incremental_present ===
506 struct PresentRegionsKHR;
507 struct PresentRegionKHR;
508 struct RectLayerKHR;
509
510 //=== VK_EXT_display_surface_counter ===
511 struct SurfaceCapabilities2EXT;
512
513 //=== VK_EXT_display_control ===
514 struct DisplayPowerInfoEXT;
515 struct DeviceEventInfoEXT;
516 struct DisplayEventInfoEXT;
517 struct SwapchainCounterCreateInfoEXT;
518
519 //=== VK_EXT_discard_rectangles ===
520 struct PhysicalDeviceDiscardRectanglePropertiesEXT;
521 struct PipelineDiscardRectangleStateCreateInfoEXT;
522
523 //=== VK_EXT_conservative_rasterization ===
524 struct PhysicalDeviceConservativeRasterizationPropertiesEXT;
525 struct PipelineRasterizationConservativeStateCreateInfoEXT;
526
527 //=== VK_EXT_depth_clip_enable ===
528 struct PhysicalDeviceDepthClipEnableFeaturesEXT;
529 struct PipelineRasterizationDepthClipStateCreateInfoEXT;
530
531 //=== VK_EXT_hdr_metadata ===
532 struct HdrMetadataEXT;
533 struct XYColorEXT;
534
535 //=== VK_KHR_shared_presentable_image ===
536 struct SharedPresentSurfaceCapabilitiesKHR;
537
538 //=== VK_KHR_external_fence_fd ===
539 struct ImportFenceFdInfoKHR;
540 struct FenceGetFdInfoKHR;
541
542 //=== VK_KHR_performance_query ===
543 struct PhysicalDevicePerformanceQueryFeaturesKHR;
544 struct PhysicalDevicePerformanceQueryPropertiesKHR;
545 struct PerformanceCounterKHR;
546 struct PerformanceCounterDescriptionKHR;
547 struct QueryPoolPerformanceCreateInfoKHR;
548 union PerformanceCounterResultKHR;
549 struct AcquireProfilingLockInfoKHR;
550 struct PerformanceQuerySubmitInfoKHR;
551 struct PerformanceQueryReservationInfoKHR;
552
553 //=== VK_KHR_get_surface_capabilities2 ===
554 struct PhysicalDeviceSurfaceInfo2KHR;
555 struct SurfaceCapabilities2KHR;
556 struct SurfaceFormat2KHR;
557
558 //=== VK_KHR_get_display_properties2 ===
559 struct DisplayProperties2KHR;
560 struct DisplayPlaneProperties2KHR;
561 struct DisplayModeProperties2KHR;
562 struct DisplayPlaneInfo2KHR;
563 struct DisplayPlaneCapabilities2KHR;
564
565 //=== VK_EXT_debug_utils ===
566 struct DebugUtilsLabelEXT;
567 struct DebugUtilsMessengerCallbackDataEXT;
568 struct DebugUtilsMessengerCreateInfoEXT;
569 struct DebugUtilsObjectNameInfoEXT;
570 struct DebugUtilsObjectTagInfoEXT;
571
572 //=== VK_EXT_sample_locations ===
573 struct SampleLocationEXT;
574 struct SampleLocationsInfoEXT;
575 struct AttachmentSampleLocationsEXT;
576 struct SubpassSampleLocationsEXT;
577 struct RenderPassSampleLocationsBeginInfoEXT;
578 struct PipelineSampleLocationsStateCreateInfoEXT;
579 struct PhysicalDeviceSampleLocationsPropertiesEXT;
580 struct MultisamplePropertiesEXT;
581
582 //=== VK_EXT_blend_operation_advanced ===
583 struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT;
584 struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT;
585 struct PipelineColorBlendAdvancedStateCreateInfoEXT;
586
587 //=== VK_EXT_image_drm_format_modifier ===
588 struct DrmFormatModifierPropertiesListEXT;
589 struct DrmFormatModifierPropertiesEXT;
590 struct PhysicalDeviceImageDrmFormatModifierInfoEXT;
591 struct ImageDrmFormatModifierListCreateInfoEXT;
592 struct ImageDrmFormatModifierExplicitCreateInfoEXT;
593 struct ImageDrmFormatModifierPropertiesEXT;
594 struct DrmFormatModifierPropertiesList2EXT;
595 struct DrmFormatModifierProperties2EXT;
596
597 //=== VK_EXT_filter_cubic ===
598 struct PhysicalDeviceImageViewImageFormatInfoEXT;
599 struct FilterCubicImageViewImageFormatPropertiesEXT;
600
601 //=== VK_EXT_external_memory_host ===
602 struct ImportMemoryHostPointerInfoEXT;
603 struct MemoryHostPointerPropertiesEXT;
604 struct PhysicalDeviceExternalMemoryHostPropertiesEXT;
605
606 //=== VK_KHR_shader_clock ===
607 struct PhysicalDeviceShaderClockFeaturesKHR;
608
609 //=== VK_EXT_calibrated_timestamps ===
610 struct CalibratedTimestampInfoEXT;
611
612 //=== VK_EXT_vertex_attribute_divisor ===
613 struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT;
614 struct VertexInputBindingDivisorDescriptionEXT;
615 struct PipelineVertexInputDivisorStateCreateInfoEXT;
616 struct PhysicalDeviceVertexAttributeDivisorFeaturesEXT;
617
618 //=== VK_EXT_pci_bus_info ===
619 struct PhysicalDevicePCIBusInfoPropertiesEXT;
620
621 //=== VK_KHR_fragment_shading_rate ===
622 struct FragmentShadingRateAttachmentInfoKHR;
623 struct PipelineFragmentShadingRateStateCreateInfoKHR;
624 struct PhysicalDeviceFragmentShadingRateFeaturesKHR;
625 struct PhysicalDeviceFragmentShadingRatePropertiesKHR;
626 struct PhysicalDeviceFragmentShadingRateKHR;
627
628 //=== VK_EXT_shader_image_atomic_int64 ===
629 struct PhysicalDeviceShaderImageAtomicInt64FeaturesEXT;
630
631 //=== VK_EXT_memory_budget ===
632 struct PhysicalDeviceMemoryBudgetPropertiesEXT;
633
634 //=== VK_EXT_validation_features ===
635 struct ValidationFeaturesEXT;
636
637 //=== VK_EXT_fragment_shader_interlock ===
638 struct PhysicalDeviceFragmentShaderInterlockFeaturesEXT;
639
640 //=== VK_EXT_ycbcr_image_arrays ===
641 struct PhysicalDeviceYcbcrImageArraysFeaturesEXT;
642
643 //=== VK_EXT_headless_surface ===
644 struct HeadlessSurfaceCreateInfoEXT;
645
646 //=== VK_EXT_line_rasterization ===
647 struct PhysicalDeviceLineRasterizationFeaturesEXT;
648 struct PhysicalDeviceLineRasterizationPropertiesEXT;
649 struct PipelineRasterizationLineStateCreateInfoEXT;
650
651 //=== VK_EXT_shader_atomic_float ===
652 struct PhysicalDeviceShaderAtomicFloatFeaturesEXT;
653
654 //=== VK_EXT_index_type_uint8 ===
655 struct PhysicalDeviceIndexTypeUint8FeaturesEXT;
656
657 //=== VK_EXT_extended_dynamic_state ===
658 struct PhysicalDeviceExtendedDynamicStateFeaturesEXT;
659
660 //=== VK_EXT_texel_buffer_alignment ===
661 struct PhysicalDeviceTexelBufferAlignmentFeaturesEXT;
662
663 //=== VK_EXT_robustness2 ===
664 struct PhysicalDeviceRobustness2FeaturesEXT;
665 struct PhysicalDeviceRobustness2PropertiesEXT;
666
667 //=== VK_EXT_custom_border_color ===
668 struct SamplerCustomBorderColorCreateInfoEXT;
669 struct PhysicalDeviceCustomBorderColorPropertiesEXT;
670 struct PhysicalDeviceCustomBorderColorFeaturesEXT;
671
672 //=== VK_KHR_object_refresh ===
673 struct RefreshObjectListKHR;
674 struct RefreshObjectKHR;
675
676 //=== VK_KHR_synchronization2 ===
677 struct QueueFamilyCheckpointProperties2NV;
678 struct CheckpointData2NV;
679
680 //=== VK_EXT_ycbcr_2plane_444_formats ===
681 struct PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT;
682
683 //=== VK_EXT_4444_formats ===
684 struct PhysicalDevice4444FormatsFeaturesEXT;
685
686 //=== VK_EXT_vertex_input_dynamic_state ===
687 struct PhysicalDeviceVertexInputDynamicStateFeaturesEXT;
688 struct VertexInputBindingDescription2EXT;
689 struct VertexInputAttributeDescription2EXT;
690
691 #if defined( VK_USE_PLATFORM_SCI )
692 //=== VK_NV_external_sci_sync ===
693 struct ExportFenceSciSyncInfoNV;
694 struct ImportFenceSciSyncInfoNV;
695 struct FenceGetSciSyncInfoNV;
696 struct SciSyncAttributesInfoNV;
697 struct ExportSemaphoreSciSyncInfoNV;
698 struct ImportSemaphoreSciSyncInfoNV;
699 struct SemaphoreGetSciSyncInfoNV;
700 struct PhysicalDeviceExternalSciSyncFeaturesNV;
701 #endif /*VK_USE_PLATFORM_SCI*/
702
703 #if defined( VK_USE_PLATFORM_SCI )
704 //=== VK_NV_external_memory_sci_buf ===
705 struct ExportMemorySciBufInfoNV;
706 struct ImportMemorySciBufInfoNV;
707 struct MemoryGetSciBufInfoNV;
708 struct MemorySciBufPropertiesNV;
709 struct PhysicalDeviceExternalMemorySciBufFeaturesNV;
710 using PhysicalDeviceExternalSciBufFeaturesNV = PhysicalDeviceExternalMemorySciBufFeaturesNV;
711 #endif /*VK_USE_PLATFORM_SCI*/
712
713 //=== VK_EXT_extended_dynamic_state2 ===
714 struct PhysicalDeviceExtendedDynamicState2FeaturesEXT;
715
716 //=== VK_EXT_color_write_enable ===
717 struct PhysicalDeviceColorWriteEnableFeaturesEXT;
718 struct PipelineColorWriteCreateInfoEXT;
719
720 //=== VK_EXT_application_parameters ===
721 struct ApplicationParametersEXT;
722
723 #if defined( VK_USE_PLATFORM_SCI )
724 //=== VK_NV_external_sci_sync2 ===
725 struct PhysicalDeviceExternalSciSync2FeaturesNV;
726 struct SemaphoreSciSyncPoolCreateInfoNV;
727 struct SemaphoreSciSyncCreateInfoNV;
728 struct DeviceSemaphoreSciSyncPoolReservationCreateInfoNV;
729 #endif /*VK_USE_PLATFORM_SCI*/
730
731 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
732 //=== VK_QNX_external_memory_screen_buffer ===
733 struct ScreenBufferPropertiesQNX;
734 struct ScreenBufferFormatPropertiesQNX;
735 struct ImportScreenBufferInfoQNX;
736 struct ExternalFormatQNX;
737 struct PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX;
738 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
739
740
741
742 //===================================
743 //=== HANDLE forward declarations ===
744 //===================================
745
746
747 //=== VK_VERSION_1_0 ===
748 class Instance;
749 class PhysicalDevice;
750 class Device;
751 class Queue;
752 class DeviceMemory;
753 class Fence;
754 class Semaphore;
755 class Event;
756 class QueryPool;
757 class Buffer;
758 class BufferView;
759 class Image;
760 class ImageView;
761 class ShaderModule;
762 class PipelineCache;
763 class Pipeline;
764 class PipelineLayout;
765 class Sampler;
766 class DescriptorPool;
767 class DescriptorSet;
768 class DescriptorSetLayout;
769 class Framebuffer;
770 class RenderPass;
771 class CommandPool;
772 class CommandBuffer;
773
774 //=== VK_VERSION_1_1 ===
775 class SamplerYcbcrConversion;
776
777 //=== VK_VERSION_1_3 ===
778 class PrivateDataSlot;
779
780 //=== VK_KHR_surface ===
781 class SurfaceKHR;
782
783 //=== VK_KHR_swapchain ===
784 class SwapchainKHR;
785
786 //=== VK_KHR_display ===
787 class DisplayKHR;
788 class DisplayModeKHR;
789
790 //=== VK_EXT_debug_utils ===
791 class DebugUtilsMessengerEXT;
792
793 #if defined( VK_USE_PLATFORM_SCI )
794 //=== VK_NV_external_sci_sync2 ===
795 class SemaphoreSciSyncPoolNV;
796 #endif /*VK_USE_PLATFORM_SCI*/
797
798
799
800 #ifndef VULKAN_HPP_NO_SMART_HANDLE
801 //======================
802 //=== UNIQUE HANDLEs ===
803 //======================
804
805
806 //=== VK_VERSION_1_0 ===
807 template <typename Dispatch>
808 class UniqueHandleTraits<Instance, Dispatch>
809 {
810 public:
811 using deleter = ObjectDestroy<NoParent, Dispatch>;
812 };
813 using UniqueInstance = UniqueHandle<Instance, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
814 template <typename Dispatch>
815 class UniqueHandleTraits<Device, Dispatch>
816 {
817 public:
818 using deleter = ObjectDestroy<NoParent, Dispatch>;
819 };
820 using UniqueDevice = UniqueHandle<Device, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
821 template <typename Dispatch>
822 class UniqueHandleTraits<Fence, Dispatch>
823 {
824 public:
825 using deleter = ObjectDestroy<Device, Dispatch>;
826 };
827 using UniqueFence = UniqueHandle<Fence, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
828 template <typename Dispatch>
829 class UniqueHandleTraits<Semaphore, Dispatch>
830 {
831 public:
832 using deleter = ObjectDestroy<Device, Dispatch>;
833 };
834 using UniqueSemaphore = UniqueHandle<Semaphore, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
835 template <typename Dispatch>
836 class UniqueHandleTraits<Event, Dispatch>
837 {
838 public:
839 using deleter = ObjectDestroy<Device, Dispatch>;
840 };
841 using UniqueEvent = UniqueHandle<Event, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
842 template <typename Dispatch>
843 class UniqueHandleTraits<Buffer, Dispatch>
844 {
845 public:
846 using deleter = ObjectDestroy<Device, Dispatch>;
847 };
848 using UniqueBuffer = UniqueHandle<Buffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
849 template <typename Dispatch>
850 class UniqueHandleTraits<BufferView, Dispatch>
851 {
852 public:
853 using deleter = ObjectDestroy<Device, Dispatch>;
854 };
855 using UniqueBufferView = UniqueHandle<BufferView, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
856 template <typename Dispatch>
857 class UniqueHandleTraits<Image, Dispatch>
858 {
859 public:
860 using deleter = ObjectDestroy<Device, Dispatch>;
861 };
862 using UniqueImage = UniqueHandle<Image, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
863 template <typename Dispatch>
864 class UniqueHandleTraits<ImageView, Dispatch>
865 {
866 public:
867 using deleter = ObjectDestroy<Device, Dispatch>;
868 };
869 using UniqueImageView = UniqueHandle<ImageView, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
870 template <typename Dispatch>
871 class UniqueHandleTraits<PipelineCache, Dispatch>
872 {
873 public:
874 using deleter = ObjectDestroy<Device, Dispatch>;
875 };
876 using UniquePipelineCache = UniqueHandle<PipelineCache, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
877 template <typename Dispatch>
878 class UniqueHandleTraits<Pipeline, Dispatch>
879 {
880 public:
881 using deleter = ObjectDestroy<Device, Dispatch>;
882 };
883 using UniquePipeline = UniqueHandle<Pipeline, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
884 template <typename Dispatch>
885 class UniqueHandleTraits<PipelineLayout, Dispatch>
886 {
887 public:
888 using deleter = ObjectDestroy<Device, Dispatch>;
889 };
890 using UniquePipelineLayout = UniqueHandle<PipelineLayout, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
891 template <typename Dispatch>
892 class UniqueHandleTraits<Sampler, Dispatch>
893 {
894 public:
895 using deleter = ObjectDestroy<Device, Dispatch>;
896 };
897 using UniqueSampler = UniqueHandle<Sampler, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
898 template <typename Dispatch>
899 class UniqueHandleTraits<DescriptorSet, Dispatch>
900 {
901 public:
902 using deleter = PoolFree<Device, DescriptorPool, Dispatch>;
903 };
904 using UniqueDescriptorSet = UniqueHandle<DescriptorSet, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
905 template <typename Dispatch>
906 class UniqueHandleTraits<DescriptorSetLayout, Dispatch>
907 {
908 public:
909 using deleter = ObjectDestroy<Device, Dispatch>;
910 };
911 using UniqueDescriptorSetLayout = UniqueHandle<DescriptorSetLayout, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
912 template <typename Dispatch>
913 class UniqueHandleTraits<Framebuffer, Dispatch>
914 {
915 public:
916 using deleter = ObjectDestroy<Device, Dispatch>;
917 };
918 using UniqueFramebuffer = UniqueHandle<Framebuffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
919 template <typename Dispatch>
920 class UniqueHandleTraits<RenderPass, Dispatch>
921 {
922 public:
923 using deleter = ObjectDestroy<Device, Dispatch>;
924 };
925 using UniqueRenderPass = UniqueHandle<RenderPass, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
926 template <typename Dispatch>
927 class UniqueHandleTraits<CommandBuffer, Dispatch>
928 {
929 public:
930 using deleter = PoolFree<Device, CommandPool, Dispatch>;
931 };
932 using UniqueCommandBuffer = UniqueHandle<CommandBuffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
933
934 //=== VK_VERSION_1_1 ===
935 template <typename Dispatch>
936 class UniqueHandleTraits<SamplerYcbcrConversion, Dispatch>
937 {
938 public:
939 using deleter = ObjectDestroy<Device, Dispatch>;
940 };
941 using UniqueSamplerYcbcrConversion = UniqueHandle<SamplerYcbcrConversion, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
942 using UniqueSamplerYcbcrConversionKHR = UniqueHandle<SamplerYcbcrConversion, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
943 //=== VK_VERSION_1_3 ===
944 template <typename Dispatch>
945 class UniqueHandleTraits<PrivateDataSlot, Dispatch>
946 {
947 public:
948 using deleter = ObjectDestroy<Device, Dispatch>;
949 };
950 using UniquePrivateDataSlot = UniqueHandle<PrivateDataSlot, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
951 using UniquePrivateDataSlotEXT = UniqueHandle<PrivateDataSlot, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
952 //=== VK_KHR_surface ===
953 template <typename Dispatch>
954 class UniqueHandleTraits<SurfaceKHR, Dispatch>
955 {
956 public:
957 using deleter = ObjectDestroy<Instance, Dispatch>;
958 };
959 using UniqueSurfaceKHR = UniqueHandle<SurfaceKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
960
961 //=== VK_KHR_display ===
962 template <typename Dispatch>
963 class UniqueHandleTraits<DisplayKHR, Dispatch>
964 {
965 public:
966 using deleter = ObjectDestroy<PhysicalDevice, Dispatch>;
967 };
968 using UniqueDisplayKHR = UniqueHandle<DisplayKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
969
970 //=== VK_EXT_debug_utils ===
971 template <typename Dispatch>
972 class UniqueHandleTraits<DebugUtilsMessengerEXT, Dispatch>
973 {
974 public:
975 using deleter = ObjectDestroy<Instance, Dispatch>;
976 };
977 using UniqueDebugUtilsMessengerEXT = UniqueHandle<DebugUtilsMessengerEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
978 #endif /*VULKAN_HPP_NO_SMART_HANDLE*/
979
980
981 //===============
982 //=== HANDLEs ===
983 //===============
984
985 template <typename Type>
986 struct isVulkanHandleType
987 {
988 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = false;
989 };
990
991 class DebugUtilsMessengerEXT
992 {
993 public:
994 using CType = VkDebugUtilsMessengerEXT;
995 using NativeType = VkDebugUtilsMessengerEXT;
996
997 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDebugUtilsMessengerEXT;
998 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
999
1000 public:
1001 VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT() = default;
DebugUtilsMessengerEXT(std::nullptr_t)1002 VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
1003 {}
DebugUtilsMessengerEXT(VkDebugUtilsMessengerEXT debugUtilsMessengerEXT)1004 VULKAN_HPP_TYPESAFE_EXPLICIT DebugUtilsMessengerEXT( VkDebugUtilsMessengerEXT debugUtilsMessengerEXT ) VULKAN_HPP_NOEXCEPT
1005 : m_debugUtilsMessengerEXT( debugUtilsMessengerEXT )
1006 {}
1007
1008 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkDebugUtilsMessengerEXT debugUtilsMessengerEXT)1009 DebugUtilsMessengerEXT & operator=(VkDebugUtilsMessengerEXT debugUtilsMessengerEXT) VULKAN_HPP_NOEXCEPT
1010 {
1011 m_debugUtilsMessengerEXT = debugUtilsMessengerEXT;
1012 return *this;
1013 }
1014 #endif
1015
operator =(std::nullptr_t)1016 DebugUtilsMessengerEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
1017 {
1018 m_debugUtilsMessengerEXT = {};
1019 return *this;
1020 }
1021
1022 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
1023 auto operator<=>( DebugUtilsMessengerEXT const & ) const = default;
1024 #else
operator ==(DebugUtilsMessengerEXT const & rhs) const1025 bool operator==( DebugUtilsMessengerEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
1026 {
1027 return m_debugUtilsMessengerEXT == rhs.m_debugUtilsMessengerEXT;
1028 }
1029
operator !=(DebugUtilsMessengerEXT const & rhs) const1030 bool operator!=(DebugUtilsMessengerEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
1031 {
1032 return m_debugUtilsMessengerEXT != rhs.m_debugUtilsMessengerEXT;
1033 }
1034
operator <(DebugUtilsMessengerEXT const & rhs) const1035 bool operator<(DebugUtilsMessengerEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
1036 {
1037 return m_debugUtilsMessengerEXT < rhs.m_debugUtilsMessengerEXT;
1038 }
1039 #endif
1040
operator VkDebugUtilsMessengerEXT() const1041 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDebugUtilsMessengerEXT() const VULKAN_HPP_NOEXCEPT
1042 {
1043 return m_debugUtilsMessengerEXT;
1044 }
1045
operator bool() const1046 explicit operator bool() const VULKAN_HPP_NOEXCEPT
1047 {
1048 return m_debugUtilsMessengerEXT != VK_NULL_HANDLE;
1049 }
1050
operator !() const1051 bool operator!() const VULKAN_HPP_NOEXCEPT
1052 {
1053 return m_debugUtilsMessengerEXT == VK_NULL_HANDLE;
1054 }
1055
1056 private:
1057 VkDebugUtilsMessengerEXT m_debugUtilsMessengerEXT = {};
1058 };
1059
1060 template <>
1061 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDebugUtilsMessengerEXT>
1062 {
1063 using Type = VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT;
1064 };
1065
1066
1067
1068 template <>
1069 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT>
1070 {
1071 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
1072 };
1073
1074 class SurfaceKHR
1075 {
1076 public:
1077 using CType = VkSurfaceKHR;
1078 using NativeType = VkSurfaceKHR;
1079
1080 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSurfaceKHR;
1081 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSurfaceKHR;
1082
1083 public:
1084 VULKAN_HPP_CONSTEXPR SurfaceKHR() = default;
SurfaceKHR(std::nullptr_t)1085 VULKAN_HPP_CONSTEXPR SurfaceKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
1086 {}
SurfaceKHR(VkSurfaceKHR surfaceKHR)1087 VULKAN_HPP_TYPESAFE_EXPLICIT SurfaceKHR( VkSurfaceKHR surfaceKHR ) VULKAN_HPP_NOEXCEPT
1088 : m_surfaceKHR( surfaceKHR )
1089 {}
1090
1091 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkSurfaceKHR surfaceKHR)1092 SurfaceKHR & operator=(VkSurfaceKHR surfaceKHR) VULKAN_HPP_NOEXCEPT
1093 {
1094 m_surfaceKHR = surfaceKHR;
1095 return *this;
1096 }
1097 #endif
1098
operator =(std::nullptr_t)1099 SurfaceKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
1100 {
1101 m_surfaceKHR = {};
1102 return *this;
1103 }
1104
1105 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
1106 auto operator<=>( SurfaceKHR const & ) const = default;
1107 #else
operator ==(SurfaceKHR const & rhs) const1108 bool operator==( SurfaceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
1109 {
1110 return m_surfaceKHR == rhs.m_surfaceKHR;
1111 }
1112
operator !=(SurfaceKHR const & rhs) const1113 bool operator!=(SurfaceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
1114 {
1115 return m_surfaceKHR != rhs.m_surfaceKHR;
1116 }
1117
operator <(SurfaceKHR const & rhs) const1118 bool operator<(SurfaceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
1119 {
1120 return m_surfaceKHR < rhs.m_surfaceKHR;
1121 }
1122 #endif
1123
operator VkSurfaceKHR() const1124 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSurfaceKHR() const VULKAN_HPP_NOEXCEPT
1125 {
1126 return m_surfaceKHR;
1127 }
1128
operator bool() const1129 explicit operator bool() const VULKAN_HPP_NOEXCEPT
1130 {
1131 return m_surfaceKHR != VK_NULL_HANDLE;
1132 }
1133
operator !() const1134 bool operator!() const VULKAN_HPP_NOEXCEPT
1135 {
1136 return m_surfaceKHR == VK_NULL_HANDLE;
1137 }
1138
1139 private:
1140 VkSurfaceKHR m_surfaceKHR = {};
1141 };
1142
1143 template <>
1144 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSurfaceKHR>
1145 {
1146 using Type = VULKAN_HPP_NAMESPACE::SurfaceKHR;
1147 };
1148
1149
1150 template <>
1151 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSurfaceKHR>
1152 {
1153 using Type = VULKAN_HPP_NAMESPACE::SurfaceKHR;
1154 };
1155
1156
1157 template <>
1158 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::SurfaceKHR>
1159 {
1160 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
1161 };
1162
1163 class SwapchainKHR
1164 {
1165 public:
1166 using CType = VkSwapchainKHR;
1167 using NativeType = VkSwapchainKHR;
1168
1169 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSwapchainKHR;
1170 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSwapchainKHR;
1171
1172 public:
1173 VULKAN_HPP_CONSTEXPR SwapchainKHR() = default;
SwapchainKHR(std::nullptr_t)1174 VULKAN_HPP_CONSTEXPR SwapchainKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
1175 {}
SwapchainKHR(VkSwapchainKHR swapchainKHR)1176 VULKAN_HPP_TYPESAFE_EXPLICIT SwapchainKHR( VkSwapchainKHR swapchainKHR ) VULKAN_HPP_NOEXCEPT
1177 : m_swapchainKHR( swapchainKHR )
1178 {}
1179
1180 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkSwapchainKHR swapchainKHR)1181 SwapchainKHR & operator=(VkSwapchainKHR swapchainKHR) VULKAN_HPP_NOEXCEPT
1182 {
1183 m_swapchainKHR = swapchainKHR;
1184 return *this;
1185 }
1186 #endif
1187
operator =(std::nullptr_t)1188 SwapchainKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
1189 {
1190 m_swapchainKHR = {};
1191 return *this;
1192 }
1193
1194 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
1195 auto operator<=>( SwapchainKHR const & ) const = default;
1196 #else
operator ==(SwapchainKHR const & rhs) const1197 bool operator==( SwapchainKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
1198 {
1199 return m_swapchainKHR == rhs.m_swapchainKHR;
1200 }
1201
operator !=(SwapchainKHR const & rhs) const1202 bool operator!=(SwapchainKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
1203 {
1204 return m_swapchainKHR != rhs.m_swapchainKHR;
1205 }
1206
operator <(SwapchainKHR const & rhs) const1207 bool operator<(SwapchainKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
1208 {
1209 return m_swapchainKHR < rhs.m_swapchainKHR;
1210 }
1211 #endif
1212
operator VkSwapchainKHR() const1213 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSwapchainKHR() const VULKAN_HPP_NOEXCEPT
1214 {
1215 return m_swapchainKHR;
1216 }
1217
operator bool() const1218 explicit operator bool() const VULKAN_HPP_NOEXCEPT
1219 {
1220 return m_swapchainKHR != VK_NULL_HANDLE;
1221 }
1222
operator !() const1223 bool operator!() const VULKAN_HPP_NOEXCEPT
1224 {
1225 return m_swapchainKHR == VK_NULL_HANDLE;
1226 }
1227
1228 private:
1229 VkSwapchainKHR m_swapchainKHR = {};
1230 };
1231
1232 template <>
1233 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSwapchainKHR>
1234 {
1235 using Type = VULKAN_HPP_NAMESPACE::SwapchainKHR;
1236 };
1237
1238
1239 template <>
1240 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSwapchainKHR>
1241 {
1242 using Type = VULKAN_HPP_NAMESPACE::SwapchainKHR;
1243 };
1244
1245
1246 template <>
1247 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::SwapchainKHR>
1248 {
1249 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
1250 };
1251
1252 class Semaphore
1253 {
1254 public:
1255 using CType = VkSemaphore;
1256 using NativeType = VkSemaphore;
1257
1258 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSemaphore;
1259 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSemaphore;
1260
1261 public:
1262 VULKAN_HPP_CONSTEXPR Semaphore() = default;
Semaphore(std::nullptr_t)1263 VULKAN_HPP_CONSTEXPR Semaphore( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
1264 {}
Semaphore(VkSemaphore semaphore)1265 VULKAN_HPP_TYPESAFE_EXPLICIT Semaphore( VkSemaphore semaphore ) VULKAN_HPP_NOEXCEPT
1266 : m_semaphore( semaphore )
1267 {}
1268
1269 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkSemaphore semaphore)1270 Semaphore & operator=(VkSemaphore semaphore) VULKAN_HPP_NOEXCEPT
1271 {
1272 m_semaphore = semaphore;
1273 return *this;
1274 }
1275 #endif
1276
operator =(std::nullptr_t)1277 Semaphore & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
1278 {
1279 m_semaphore = {};
1280 return *this;
1281 }
1282
1283 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
1284 auto operator<=>( Semaphore const & ) const = default;
1285 #else
operator ==(Semaphore const & rhs) const1286 bool operator==( Semaphore const & rhs ) const VULKAN_HPP_NOEXCEPT
1287 {
1288 return m_semaphore == rhs.m_semaphore;
1289 }
1290
operator !=(Semaphore const & rhs) const1291 bool operator!=(Semaphore const & rhs ) const VULKAN_HPP_NOEXCEPT
1292 {
1293 return m_semaphore != rhs.m_semaphore;
1294 }
1295
operator <(Semaphore const & rhs) const1296 bool operator<(Semaphore const & rhs ) const VULKAN_HPP_NOEXCEPT
1297 {
1298 return m_semaphore < rhs.m_semaphore;
1299 }
1300 #endif
1301
operator VkSemaphore() const1302 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSemaphore() const VULKAN_HPP_NOEXCEPT
1303 {
1304 return m_semaphore;
1305 }
1306
operator bool() const1307 explicit operator bool() const VULKAN_HPP_NOEXCEPT
1308 {
1309 return m_semaphore != VK_NULL_HANDLE;
1310 }
1311
operator !() const1312 bool operator!() const VULKAN_HPP_NOEXCEPT
1313 {
1314 return m_semaphore == VK_NULL_HANDLE;
1315 }
1316
1317 private:
1318 VkSemaphore m_semaphore = {};
1319 };
1320
1321 template <>
1322 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSemaphore>
1323 {
1324 using Type = VULKAN_HPP_NAMESPACE::Semaphore;
1325 };
1326
1327
1328 template <>
1329 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSemaphore>
1330 {
1331 using Type = VULKAN_HPP_NAMESPACE::Semaphore;
1332 };
1333
1334
1335 template <>
1336 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Semaphore>
1337 {
1338 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
1339 };
1340
1341 class Fence
1342 {
1343 public:
1344 using CType = VkFence;
1345 using NativeType = VkFence;
1346
1347 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eFence;
1348 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFence;
1349
1350 public:
1351 VULKAN_HPP_CONSTEXPR Fence() = default;
Fence(std::nullptr_t)1352 VULKAN_HPP_CONSTEXPR Fence( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
1353 {}
Fence(VkFence fence)1354 VULKAN_HPP_TYPESAFE_EXPLICIT Fence( VkFence fence ) VULKAN_HPP_NOEXCEPT
1355 : m_fence( fence )
1356 {}
1357
1358 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkFence fence)1359 Fence & operator=(VkFence fence) VULKAN_HPP_NOEXCEPT
1360 {
1361 m_fence = fence;
1362 return *this;
1363 }
1364 #endif
1365
operator =(std::nullptr_t)1366 Fence & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
1367 {
1368 m_fence = {};
1369 return *this;
1370 }
1371
1372 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
1373 auto operator<=>( Fence const & ) const = default;
1374 #else
operator ==(Fence const & rhs) const1375 bool operator==( Fence const & rhs ) const VULKAN_HPP_NOEXCEPT
1376 {
1377 return m_fence == rhs.m_fence;
1378 }
1379
operator !=(Fence const & rhs) const1380 bool operator!=(Fence const & rhs ) const VULKAN_HPP_NOEXCEPT
1381 {
1382 return m_fence != rhs.m_fence;
1383 }
1384
operator <(Fence const & rhs) const1385 bool operator<(Fence const & rhs ) const VULKAN_HPP_NOEXCEPT
1386 {
1387 return m_fence < rhs.m_fence;
1388 }
1389 #endif
1390
operator VkFence() const1391 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkFence() const VULKAN_HPP_NOEXCEPT
1392 {
1393 return m_fence;
1394 }
1395
operator bool() const1396 explicit operator bool() const VULKAN_HPP_NOEXCEPT
1397 {
1398 return m_fence != VK_NULL_HANDLE;
1399 }
1400
operator !() const1401 bool operator!() const VULKAN_HPP_NOEXCEPT
1402 {
1403 return m_fence == VK_NULL_HANDLE;
1404 }
1405
1406 private:
1407 VkFence m_fence = {};
1408 };
1409
1410 template <>
1411 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eFence>
1412 {
1413 using Type = VULKAN_HPP_NAMESPACE::Fence;
1414 };
1415
1416
1417 template <>
1418 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFence>
1419 {
1420 using Type = VULKAN_HPP_NAMESPACE::Fence;
1421 };
1422
1423
1424 template <>
1425 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Fence>
1426 {
1427 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
1428 };
1429
1430 class QueryPool
1431 {
1432 public:
1433 using CType = VkQueryPool;
1434 using NativeType = VkQueryPool;
1435
1436 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eQueryPool;
1437 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueryPool;
1438
1439 public:
1440 VULKAN_HPP_CONSTEXPR QueryPool() = default;
QueryPool(std::nullptr_t)1441 VULKAN_HPP_CONSTEXPR QueryPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
1442 {}
QueryPool(VkQueryPool queryPool)1443 VULKAN_HPP_TYPESAFE_EXPLICIT QueryPool( VkQueryPool queryPool ) VULKAN_HPP_NOEXCEPT
1444 : m_queryPool( queryPool )
1445 {}
1446
1447 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkQueryPool queryPool)1448 QueryPool & operator=(VkQueryPool queryPool) VULKAN_HPP_NOEXCEPT
1449 {
1450 m_queryPool = queryPool;
1451 return *this;
1452 }
1453 #endif
1454
operator =(std::nullptr_t)1455 QueryPool & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
1456 {
1457 m_queryPool = {};
1458 return *this;
1459 }
1460
1461 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
1462 auto operator<=>( QueryPool const & ) const = default;
1463 #else
operator ==(QueryPool const & rhs) const1464 bool operator==( QueryPool const & rhs ) const VULKAN_HPP_NOEXCEPT
1465 {
1466 return m_queryPool == rhs.m_queryPool;
1467 }
1468
operator !=(QueryPool const & rhs) const1469 bool operator!=(QueryPool const & rhs ) const VULKAN_HPP_NOEXCEPT
1470 {
1471 return m_queryPool != rhs.m_queryPool;
1472 }
1473
operator <(QueryPool const & rhs) const1474 bool operator<(QueryPool const & rhs ) const VULKAN_HPP_NOEXCEPT
1475 {
1476 return m_queryPool < rhs.m_queryPool;
1477 }
1478 #endif
1479
operator VkQueryPool() const1480 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkQueryPool() const VULKAN_HPP_NOEXCEPT
1481 {
1482 return m_queryPool;
1483 }
1484
operator bool() const1485 explicit operator bool() const VULKAN_HPP_NOEXCEPT
1486 {
1487 return m_queryPool != VK_NULL_HANDLE;
1488 }
1489
operator !() const1490 bool operator!() const VULKAN_HPP_NOEXCEPT
1491 {
1492 return m_queryPool == VK_NULL_HANDLE;
1493 }
1494
1495 private:
1496 VkQueryPool m_queryPool = {};
1497 };
1498
1499 template <>
1500 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eQueryPool>
1501 {
1502 using Type = VULKAN_HPP_NAMESPACE::QueryPool;
1503 };
1504
1505
1506 template <>
1507 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueryPool>
1508 {
1509 using Type = VULKAN_HPP_NAMESPACE::QueryPool;
1510 };
1511
1512
1513 template <>
1514 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::QueryPool>
1515 {
1516 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
1517 };
1518
1519 class PipelineLayout
1520 {
1521 public:
1522 using CType = VkPipelineLayout;
1523 using NativeType = VkPipelineLayout;
1524
1525 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePipelineLayout;
1526 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineLayout;
1527
1528 public:
1529 VULKAN_HPP_CONSTEXPR PipelineLayout() = default;
PipelineLayout(std::nullptr_t)1530 VULKAN_HPP_CONSTEXPR PipelineLayout( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
1531 {}
PipelineLayout(VkPipelineLayout pipelineLayout)1532 VULKAN_HPP_TYPESAFE_EXPLICIT PipelineLayout( VkPipelineLayout pipelineLayout ) VULKAN_HPP_NOEXCEPT
1533 : m_pipelineLayout( pipelineLayout )
1534 {}
1535
1536 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkPipelineLayout pipelineLayout)1537 PipelineLayout & operator=(VkPipelineLayout pipelineLayout) VULKAN_HPP_NOEXCEPT
1538 {
1539 m_pipelineLayout = pipelineLayout;
1540 return *this;
1541 }
1542 #endif
1543
operator =(std::nullptr_t)1544 PipelineLayout & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
1545 {
1546 m_pipelineLayout = {};
1547 return *this;
1548 }
1549
1550 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
1551 auto operator<=>( PipelineLayout const & ) const = default;
1552 #else
operator ==(PipelineLayout const & rhs) const1553 bool operator==( PipelineLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
1554 {
1555 return m_pipelineLayout == rhs.m_pipelineLayout;
1556 }
1557
operator !=(PipelineLayout const & rhs) const1558 bool operator!=(PipelineLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
1559 {
1560 return m_pipelineLayout != rhs.m_pipelineLayout;
1561 }
1562
operator <(PipelineLayout const & rhs) const1563 bool operator<(PipelineLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
1564 {
1565 return m_pipelineLayout < rhs.m_pipelineLayout;
1566 }
1567 #endif
1568
operator VkPipelineLayout() const1569 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineLayout() const VULKAN_HPP_NOEXCEPT
1570 {
1571 return m_pipelineLayout;
1572 }
1573
operator bool() const1574 explicit operator bool() const VULKAN_HPP_NOEXCEPT
1575 {
1576 return m_pipelineLayout != VK_NULL_HANDLE;
1577 }
1578
operator !() const1579 bool operator!() const VULKAN_HPP_NOEXCEPT
1580 {
1581 return m_pipelineLayout == VK_NULL_HANDLE;
1582 }
1583
1584 private:
1585 VkPipelineLayout m_pipelineLayout = {};
1586 };
1587
1588 template <>
1589 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePipelineLayout>
1590 {
1591 using Type = VULKAN_HPP_NAMESPACE::PipelineLayout;
1592 };
1593
1594
1595 template <>
1596 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineLayout>
1597 {
1598 using Type = VULKAN_HPP_NAMESPACE::PipelineLayout;
1599 };
1600
1601
1602 template <>
1603 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PipelineLayout>
1604 {
1605 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
1606 };
1607
1608 class DescriptorSet
1609 {
1610 public:
1611 using CType = VkDescriptorSet;
1612 using NativeType = VkDescriptorSet;
1613
1614 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSet;
1615 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSet;
1616
1617 public:
1618 VULKAN_HPP_CONSTEXPR DescriptorSet() = default;
DescriptorSet(std::nullptr_t)1619 VULKAN_HPP_CONSTEXPR DescriptorSet( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
1620 {}
DescriptorSet(VkDescriptorSet descriptorSet)1621 VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSet( VkDescriptorSet descriptorSet ) VULKAN_HPP_NOEXCEPT
1622 : m_descriptorSet( descriptorSet )
1623 {}
1624
1625 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkDescriptorSet descriptorSet)1626 DescriptorSet & operator=(VkDescriptorSet descriptorSet) VULKAN_HPP_NOEXCEPT
1627 {
1628 m_descriptorSet = descriptorSet;
1629 return *this;
1630 }
1631 #endif
1632
operator =(std::nullptr_t)1633 DescriptorSet & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
1634 {
1635 m_descriptorSet = {};
1636 return *this;
1637 }
1638
1639 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
1640 auto operator<=>( DescriptorSet const & ) const = default;
1641 #else
operator ==(DescriptorSet const & rhs) const1642 bool operator==( DescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT
1643 {
1644 return m_descriptorSet == rhs.m_descriptorSet;
1645 }
1646
operator !=(DescriptorSet const & rhs) const1647 bool operator!=(DescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT
1648 {
1649 return m_descriptorSet != rhs.m_descriptorSet;
1650 }
1651
operator <(DescriptorSet const & rhs) const1652 bool operator<(DescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT
1653 {
1654 return m_descriptorSet < rhs.m_descriptorSet;
1655 }
1656 #endif
1657
operator VkDescriptorSet() const1658 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorSet() const VULKAN_HPP_NOEXCEPT
1659 {
1660 return m_descriptorSet;
1661 }
1662
operator bool() const1663 explicit operator bool() const VULKAN_HPP_NOEXCEPT
1664 {
1665 return m_descriptorSet != VK_NULL_HANDLE;
1666 }
1667
operator !() const1668 bool operator!() const VULKAN_HPP_NOEXCEPT
1669 {
1670 return m_descriptorSet == VK_NULL_HANDLE;
1671 }
1672
1673 private:
1674 VkDescriptorSet m_descriptorSet = {};
1675 };
1676
1677 template <>
1678 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSet>
1679 {
1680 using Type = VULKAN_HPP_NAMESPACE::DescriptorSet;
1681 };
1682
1683
1684 template <>
1685 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSet>
1686 {
1687 using Type = VULKAN_HPP_NAMESPACE::DescriptorSet;
1688 };
1689
1690
1691 template <>
1692 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DescriptorSet>
1693 {
1694 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
1695 };
1696
1697 class Buffer
1698 {
1699 public:
1700 using CType = VkBuffer;
1701 using NativeType = VkBuffer;
1702
1703 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eBuffer;
1704 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBuffer;
1705
1706 public:
1707 VULKAN_HPP_CONSTEXPR Buffer() = default;
Buffer(std::nullptr_t)1708 VULKAN_HPP_CONSTEXPR Buffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
1709 {}
Buffer(VkBuffer buffer)1710 VULKAN_HPP_TYPESAFE_EXPLICIT Buffer( VkBuffer buffer ) VULKAN_HPP_NOEXCEPT
1711 : m_buffer( buffer )
1712 {}
1713
1714 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkBuffer buffer)1715 Buffer & operator=(VkBuffer buffer) VULKAN_HPP_NOEXCEPT
1716 {
1717 m_buffer = buffer;
1718 return *this;
1719 }
1720 #endif
1721
operator =(std::nullptr_t)1722 Buffer & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
1723 {
1724 m_buffer = {};
1725 return *this;
1726 }
1727
1728 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
1729 auto operator<=>( Buffer const & ) const = default;
1730 #else
operator ==(Buffer const & rhs) const1731 bool operator==( Buffer const & rhs ) const VULKAN_HPP_NOEXCEPT
1732 {
1733 return m_buffer == rhs.m_buffer;
1734 }
1735
operator !=(Buffer const & rhs) const1736 bool operator!=(Buffer const & rhs ) const VULKAN_HPP_NOEXCEPT
1737 {
1738 return m_buffer != rhs.m_buffer;
1739 }
1740
operator <(Buffer const & rhs) const1741 bool operator<(Buffer const & rhs ) const VULKAN_HPP_NOEXCEPT
1742 {
1743 return m_buffer < rhs.m_buffer;
1744 }
1745 #endif
1746
operator VkBuffer() const1747 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBuffer() const VULKAN_HPP_NOEXCEPT
1748 {
1749 return m_buffer;
1750 }
1751
operator bool() const1752 explicit operator bool() const VULKAN_HPP_NOEXCEPT
1753 {
1754 return m_buffer != VK_NULL_HANDLE;
1755 }
1756
operator !() const1757 bool operator!() const VULKAN_HPP_NOEXCEPT
1758 {
1759 return m_buffer == VK_NULL_HANDLE;
1760 }
1761
1762 private:
1763 VkBuffer m_buffer = {};
1764 };
1765
1766 template <>
1767 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eBuffer>
1768 {
1769 using Type = VULKAN_HPP_NAMESPACE::Buffer;
1770 };
1771
1772
1773 template <>
1774 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBuffer>
1775 {
1776 using Type = VULKAN_HPP_NAMESPACE::Buffer;
1777 };
1778
1779
1780 template <>
1781 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Buffer>
1782 {
1783 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
1784 };
1785
1786 class Pipeline
1787 {
1788 public:
1789 using CType = VkPipeline;
1790 using NativeType = VkPipeline;
1791
1792 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePipeline;
1793 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipeline;
1794
1795 public:
1796 VULKAN_HPP_CONSTEXPR Pipeline() = default;
Pipeline(std::nullptr_t)1797 VULKAN_HPP_CONSTEXPR Pipeline( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
1798 {}
Pipeline(VkPipeline pipeline)1799 VULKAN_HPP_TYPESAFE_EXPLICIT Pipeline( VkPipeline pipeline ) VULKAN_HPP_NOEXCEPT
1800 : m_pipeline( pipeline )
1801 {}
1802
1803 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkPipeline pipeline)1804 Pipeline & operator=(VkPipeline pipeline) VULKAN_HPP_NOEXCEPT
1805 {
1806 m_pipeline = pipeline;
1807 return *this;
1808 }
1809 #endif
1810
operator =(std::nullptr_t)1811 Pipeline & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
1812 {
1813 m_pipeline = {};
1814 return *this;
1815 }
1816
1817 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
1818 auto operator<=>( Pipeline const & ) const = default;
1819 #else
operator ==(Pipeline const & rhs) const1820 bool operator==( Pipeline const & rhs ) const VULKAN_HPP_NOEXCEPT
1821 {
1822 return m_pipeline == rhs.m_pipeline;
1823 }
1824
operator !=(Pipeline const & rhs) const1825 bool operator!=(Pipeline const & rhs ) const VULKAN_HPP_NOEXCEPT
1826 {
1827 return m_pipeline != rhs.m_pipeline;
1828 }
1829
operator <(Pipeline const & rhs) const1830 bool operator<(Pipeline const & rhs ) const VULKAN_HPP_NOEXCEPT
1831 {
1832 return m_pipeline < rhs.m_pipeline;
1833 }
1834 #endif
1835
operator VkPipeline() const1836 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipeline() const VULKAN_HPP_NOEXCEPT
1837 {
1838 return m_pipeline;
1839 }
1840
operator bool() const1841 explicit operator bool() const VULKAN_HPP_NOEXCEPT
1842 {
1843 return m_pipeline != VK_NULL_HANDLE;
1844 }
1845
operator !() const1846 bool operator!() const VULKAN_HPP_NOEXCEPT
1847 {
1848 return m_pipeline == VK_NULL_HANDLE;
1849 }
1850
1851 private:
1852 VkPipeline m_pipeline = {};
1853 };
1854
1855 template <>
1856 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePipeline>
1857 {
1858 using Type = VULKAN_HPP_NAMESPACE::Pipeline;
1859 };
1860
1861
1862 template <>
1863 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipeline>
1864 {
1865 using Type = VULKAN_HPP_NAMESPACE::Pipeline;
1866 };
1867
1868
1869 template <>
1870 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Pipeline>
1871 {
1872 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
1873 };
1874
1875 class Image
1876 {
1877 public:
1878 using CType = VkImage;
1879 using NativeType = VkImage;
1880
1881 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eImage;
1882 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImage;
1883
1884 public:
1885 VULKAN_HPP_CONSTEXPR Image() = default;
Image(std::nullptr_t)1886 VULKAN_HPP_CONSTEXPR Image( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
1887 {}
Image(VkImage image)1888 VULKAN_HPP_TYPESAFE_EXPLICIT Image( VkImage image ) VULKAN_HPP_NOEXCEPT
1889 : m_image( image )
1890 {}
1891
1892 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkImage image)1893 Image & operator=(VkImage image) VULKAN_HPP_NOEXCEPT
1894 {
1895 m_image = image;
1896 return *this;
1897 }
1898 #endif
1899
operator =(std::nullptr_t)1900 Image & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
1901 {
1902 m_image = {};
1903 return *this;
1904 }
1905
1906 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
1907 auto operator<=>( Image const & ) const = default;
1908 #else
operator ==(Image const & rhs) const1909 bool operator==( Image const & rhs ) const VULKAN_HPP_NOEXCEPT
1910 {
1911 return m_image == rhs.m_image;
1912 }
1913
operator !=(Image const & rhs) const1914 bool operator!=(Image const & rhs ) const VULKAN_HPP_NOEXCEPT
1915 {
1916 return m_image != rhs.m_image;
1917 }
1918
operator <(Image const & rhs) const1919 bool operator<(Image const & rhs ) const VULKAN_HPP_NOEXCEPT
1920 {
1921 return m_image < rhs.m_image;
1922 }
1923 #endif
1924
operator VkImage() const1925 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkImage() const VULKAN_HPP_NOEXCEPT
1926 {
1927 return m_image;
1928 }
1929
operator bool() const1930 explicit operator bool() const VULKAN_HPP_NOEXCEPT
1931 {
1932 return m_image != VK_NULL_HANDLE;
1933 }
1934
operator !() const1935 bool operator!() const VULKAN_HPP_NOEXCEPT
1936 {
1937 return m_image == VK_NULL_HANDLE;
1938 }
1939
1940 private:
1941 VkImage m_image = {};
1942 };
1943
1944 template <>
1945 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eImage>
1946 {
1947 using Type = VULKAN_HPP_NAMESPACE::Image;
1948 };
1949
1950
1951 template <>
1952 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImage>
1953 {
1954 using Type = VULKAN_HPP_NAMESPACE::Image;
1955 };
1956
1957
1958 template <>
1959 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Image>
1960 {
1961 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
1962 };
1963
1964 class Event
1965 {
1966 public:
1967 using CType = VkEvent;
1968 using NativeType = VkEvent;
1969
1970 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eEvent;
1971 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eEvent;
1972
1973 public:
1974 VULKAN_HPP_CONSTEXPR Event() = default;
Event(std::nullptr_t)1975 VULKAN_HPP_CONSTEXPR Event( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
1976 {}
Event(VkEvent event)1977 VULKAN_HPP_TYPESAFE_EXPLICIT Event( VkEvent event ) VULKAN_HPP_NOEXCEPT
1978 : m_event( event )
1979 {}
1980
1981 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkEvent event)1982 Event & operator=(VkEvent event) VULKAN_HPP_NOEXCEPT
1983 {
1984 m_event = event;
1985 return *this;
1986 }
1987 #endif
1988
operator =(std::nullptr_t)1989 Event & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
1990 {
1991 m_event = {};
1992 return *this;
1993 }
1994
1995 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
1996 auto operator<=>( Event const & ) const = default;
1997 #else
operator ==(Event const & rhs) const1998 bool operator==( Event const & rhs ) const VULKAN_HPP_NOEXCEPT
1999 {
2000 return m_event == rhs.m_event;
2001 }
2002
operator !=(Event const & rhs) const2003 bool operator!=(Event const & rhs ) const VULKAN_HPP_NOEXCEPT
2004 {
2005 return m_event != rhs.m_event;
2006 }
2007
operator <(Event const & rhs) const2008 bool operator<(Event const & rhs ) const VULKAN_HPP_NOEXCEPT
2009 {
2010 return m_event < rhs.m_event;
2011 }
2012 #endif
2013
operator VkEvent() const2014 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkEvent() const VULKAN_HPP_NOEXCEPT
2015 {
2016 return m_event;
2017 }
2018
operator bool() const2019 explicit operator bool() const VULKAN_HPP_NOEXCEPT
2020 {
2021 return m_event != VK_NULL_HANDLE;
2022 }
2023
operator !() const2024 bool operator!() const VULKAN_HPP_NOEXCEPT
2025 {
2026 return m_event == VK_NULL_HANDLE;
2027 }
2028
2029 private:
2030 VkEvent m_event = {};
2031 };
2032
2033 template <>
2034 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eEvent>
2035 {
2036 using Type = VULKAN_HPP_NAMESPACE::Event;
2037 };
2038
2039
2040 template <>
2041 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eEvent>
2042 {
2043 using Type = VULKAN_HPP_NAMESPACE::Event;
2044 };
2045
2046
2047 template <>
2048 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Event>
2049 {
2050 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2051 };
2052
2053 class CommandBuffer
2054 {
2055 public:
2056 using CType = VkCommandBuffer;
2057 using NativeType = VkCommandBuffer;
2058
2059 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCommandBuffer;
2060 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandBuffer;
2061
2062 public:
2063 VULKAN_HPP_CONSTEXPR CommandBuffer() = default;
CommandBuffer(std::nullptr_t)2064 VULKAN_HPP_CONSTEXPR CommandBuffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2065 {}
CommandBuffer(VkCommandBuffer commandBuffer)2066 CommandBuffer( VkCommandBuffer commandBuffer ) VULKAN_HPP_NOEXCEPT
2067 : m_commandBuffer( commandBuffer )
2068 {}
2069
operator =(VkCommandBuffer commandBuffer)2070 CommandBuffer & operator=(VkCommandBuffer commandBuffer) VULKAN_HPP_NOEXCEPT
2071 {
2072 m_commandBuffer = commandBuffer;
2073 return *this;
2074 }
2075
operator =(std::nullptr_t)2076 CommandBuffer & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2077 {
2078 m_commandBuffer = {};
2079 return *this;
2080 }
2081
2082 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
2083 auto operator<=>( CommandBuffer const & ) const = default;
2084 #else
operator ==(CommandBuffer const & rhs) const2085 bool operator==( CommandBuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
2086 {
2087 return m_commandBuffer == rhs.m_commandBuffer;
2088 }
2089
operator !=(CommandBuffer const & rhs) const2090 bool operator!=(CommandBuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
2091 {
2092 return m_commandBuffer != rhs.m_commandBuffer;
2093 }
2094
operator <(CommandBuffer const & rhs) const2095 bool operator<(CommandBuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
2096 {
2097 return m_commandBuffer < rhs.m_commandBuffer;
2098 }
2099 #endif
2100
2101 //=== VK_VERSION_1_0 ===
2102
2103
2104 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2105 VULKAN_HPP_NODISCARD Result begin( const VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo * pBeginInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2106 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2107 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2108 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;
2109 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2110
2111
2112 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
2113 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2114 VULKAN_HPP_NODISCARD Result end( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2115 #else
2116 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2117 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type end( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
2118 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
2119
2120
2121 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
2122 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2123 VULKAN_HPP_NODISCARD Result reset( VULKAN_HPP_NAMESPACE::CommandBufferResetFlags flags, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2124 #else
2125 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2126 typename ResultValueType<void>::type reset( VULKAN_HPP_NAMESPACE::CommandBufferResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
2127 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
2128
2129
2130 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2131 void bindPipeline( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, VULKAN_HPP_NAMESPACE::Pipeline pipeline, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2132
2133
2134 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2135 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;
2136 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2137 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2138 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;
2139 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2140
2141
2142 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2143 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;
2144 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2145 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2146 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;
2147 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2148
2149
2150 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2151 void setLineWidth( float lineWidth, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2152
2153
2154 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2155 void setDepthBias( float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2156
2157
2158 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2159 void setBlendConstants( const float blendConstants[4], Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2160
2161
2162 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2163 void setDepthBounds( float minDepthBounds, float maxDepthBounds, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2164
2165
2166 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2167 void setStencilCompareMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, uint32_t compareMask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2168
2169
2170 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2171 void setStencilWriteMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, uint32_t writeMask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2172
2173
2174 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2175 void setStencilReference( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, uint32_t reference, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2176
2177
2178 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2179 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;
2180 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2181 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2182 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;
2183 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2184
2185
2186 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2187 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;
2188
2189
2190 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2191 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;
2192 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2193 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2194 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;
2195 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2196
2197
2198 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2199 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;
2200
2201
2202 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2203 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;
2204
2205
2206 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2207 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;
2208
2209
2210 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2211 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;
2212
2213
2214 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2215 void dispatch( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2216
2217
2218 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2219 void dispatchIndirect( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2220
2221
2222 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2223 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;
2224 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2225 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2226 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;
2227 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2228
2229
2230 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2231 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;
2232 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2233 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2234 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;
2235 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2236
2237
2238 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2239 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;
2240 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2241 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2242 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;
2243 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2244
2245
2246 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2247 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;
2248 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2249 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2250 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;
2251 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2252
2253
2254 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2255 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;
2256 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2257 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2258 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;
2259 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2260
2261
2262 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2263 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;
2264 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2265 template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2266 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;
2267 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2268
2269
2270 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2271 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;
2272
2273
2274 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2275 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;
2276 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2277 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2278 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;
2279 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2280
2281
2282 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2283 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;
2284 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2285 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2286 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;
2287 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2288
2289
2290 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2291 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;
2292 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2293 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2294 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;
2295 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2296
2297
2298 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2299 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;
2300 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2301 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2302 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;
2303 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2304
2305
2306 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2307 void setEvent( VULKAN_HPP_NAMESPACE::Event event, VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2308
2309
2310 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2311 void resetEvent( VULKAN_HPP_NAMESPACE::Event event, VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2312
2313
2314 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2315 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;
2316 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2317 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2318 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;
2319 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2320
2321
2322 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2323 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;
2324 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2325 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2326 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;
2327 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2328
2329
2330 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2331 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;
2332
2333
2334 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2335 void endQuery( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2336
2337
2338 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2339 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;
2340
2341
2342 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2343 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;
2344
2345
2346 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2347 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;
2348
2349
2350 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2351 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;
2352 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2353 template <typename ValuesType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2354 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;
2355 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2356
2357
2358 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2359 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;
2360 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2361 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2362 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;
2363 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2364
2365
2366 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2367 void nextSubpass( VULKAN_HPP_NAMESPACE::SubpassContents contents, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2368
2369
2370 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2371 void endRenderPass( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2372
2373
2374 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2375 void executeCommands( uint32_t commandBufferCount, const VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2376 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2377 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2378 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;
2379 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2380
2381 //=== VK_VERSION_1_1 ===
2382
2383
2384 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2385 void setDeviceMask( uint32_t deviceMask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2386
2387
2388 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2389 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;
2390
2391 //=== VK_VERSION_1_2 ===
2392
2393
2394 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2395 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;
2396
2397
2398 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2399 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;
2400
2401
2402 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2403 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;
2404 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2405 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2406 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;
2407 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2408
2409
2410 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2411 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;
2412 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2413 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2414 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;
2415 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2416
2417
2418 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2419 void endRenderPass2( const VULKAN_HPP_NAMESPACE::SubpassEndInfo * pSubpassEndInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2420 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2421 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2422 void endRenderPass2( const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2423 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2424
2425 //=== VK_VERSION_1_3 ===
2426
2427
2428 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2429 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;
2430 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2431 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2432 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;
2433 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2434
2435
2436 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2437 void resetEvent2( VULKAN_HPP_NAMESPACE::Event event, VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stageMask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2438
2439
2440 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2441 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;
2442 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2443 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2444 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;
2445 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2446
2447
2448 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2449 void pipelineBarrier2( const VULKAN_HPP_NAMESPACE::DependencyInfo * pDependencyInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2450 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2451 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2452 void pipelineBarrier2( const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2453 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2454
2455
2456 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2457 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;
2458
2459
2460 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2461 void copyBuffer2( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 * pCopyBufferInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2462 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2463 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2464 void copyBuffer2( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 & copyBufferInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2465 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2466
2467
2468 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2469 void copyImage2( const VULKAN_HPP_NAMESPACE::CopyImageInfo2 * pCopyImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2470 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2471 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2472 void copyImage2( const VULKAN_HPP_NAMESPACE::CopyImageInfo2 & copyImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2473 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2474
2475
2476 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2477 void copyBufferToImage2( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 * pCopyBufferToImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2478 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2479 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2480 void copyBufferToImage2( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 & copyBufferToImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2481 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2482
2483
2484 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2485 void copyImageToBuffer2( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 * pCopyImageToBufferInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2486 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2487 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2488 void copyImageToBuffer2( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 & copyImageToBufferInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2489 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2490
2491
2492 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2493 void blitImage2( const VULKAN_HPP_NAMESPACE::BlitImageInfo2 * pBlitImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2494 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2495 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2496 void blitImage2( const VULKAN_HPP_NAMESPACE::BlitImageInfo2 & blitImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2497 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2498
2499
2500 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2501 void resolveImage2( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 * pResolveImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2502 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2503 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2504 void resolveImage2( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 & resolveImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2505 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2506
2507
2508 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2509 void beginRendering( const VULKAN_HPP_NAMESPACE::RenderingInfo * pRenderingInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2510 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2511 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2512 void beginRendering( const VULKAN_HPP_NAMESPACE::RenderingInfo & renderingInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2513 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2514
2515
2516 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2517 void endRendering( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2518
2519
2520 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2521 void setCullMode( VULKAN_HPP_NAMESPACE::CullModeFlags cullMode, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2522
2523
2524 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2525 void setFrontFace( VULKAN_HPP_NAMESPACE::FrontFace frontFace, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2526
2527
2528 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2529 void setPrimitiveTopology( VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2530
2531
2532 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2533 void setViewportWithCount( uint32_t viewportCount, const VULKAN_HPP_NAMESPACE::Viewport * pViewports, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2534 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2535 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2536 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;
2537 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2538
2539
2540 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2541 void setScissorWithCount( uint32_t scissorCount, const VULKAN_HPP_NAMESPACE::Rect2D * pScissors, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2542 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2543 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2544 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;
2545 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2546
2547
2548 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2549 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;
2550 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2551 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2552 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;
2553 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2554
2555
2556 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2557 void setDepthTestEnable( VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2558
2559
2560 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2561 void setDepthWriteEnable( VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2562
2563
2564 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2565 void setDepthCompareOp( VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2566
2567
2568 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2569 void setDepthBoundsTestEnable( VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2570
2571
2572 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2573 void setStencilTestEnable( VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2574
2575
2576 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2577 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;
2578
2579
2580 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2581 void setRasterizerDiscardEnable( VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2582
2583
2584 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2585 void setDepthBiasEnable( VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2586
2587
2588 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2589 void setPrimitiveRestartEnable( VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2590
2591 //=== VK_EXT_discard_rectangles ===
2592
2593
2594 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2595 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;
2596 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2597 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2598 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;
2599 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2600
2601
2602 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2603 void setDiscardRectangleEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 discardRectangleEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2604
2605
2606 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2607 void setDiscardRectangleModeEXT( VULKAN_HPP_NAMESPACE::DiscardRectangleModeEXT discardRectangleMode, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2608
2609 //=== VK_EXT_debug_utils ===
2610
2611
2612 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2613 void beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2614 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2615 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2616 void beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2617 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2618
2619
2620 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2621 void endDebugUtilsLabelEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2622
2623
2624 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2625 void insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2626 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2627 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2628 void insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2629 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2630
2631 //=== VK_EXT_sample_locations ===
2632
2633
2634 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2635 void setSampleLocationsEXT( const VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT * pSampleLocationsInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2636 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2637 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2638 void setSampleLocationsEXT( const VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT & sampleLocationsInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2639 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2640
2641 //=== VK_KHR_fragment_shading_rate ===
2642
2643
2644 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2645 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;
2646 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2647 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2648 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;
2649 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2650
2651 //=== VK_EXT_line_rasterization ===
2652
2653
2654 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2655 void setLineStippleEXT( uint32_t lineStippleFactor, uint16_t lineStipplePattern, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2656
2657 //=== VK_EXT_extended_dynamic_state ===
2658
2659
2660 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2661 void setCullModeEXT( VULKAN_HPP_NAMESPACE::CullModeFlags cullMode, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2662
2663
2664 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2665 void setFrontFaceEXT( VULKAN_HPP_NAMESPACE::FrontFace frontFace, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2666
2667
2668 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2669 void setPrimitiveTopologyEXT( VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2670
2671
2672 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2673 void setViewportWithCountEXT( uint32_t viewportCount, const VULKAN_HPP_NAMESPACE::Viewport * pViewports, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2674 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2675 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2676 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;
2677 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2678
2679
2680 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2681 void setScissorWithCountEXT( uint32_t scissorCount, const VULKAN_HPP_NAMESPACE::Rect2D * pScissors, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2682 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2683 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2684 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;
2685 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2686
2687
2688 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2689 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;
2690 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2691 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2692 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;
2693 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2694
2695
2696 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2697 void setDepthTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2698
2699
2700 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2701 void setDepthWriteEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2702
2703
2704 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2705 void setDepthCompareOpEXT( VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2706
2707
2708 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2709 void setDepthBoundsTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2710
2711
2712 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2713 void setStencilTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2714
2715
2716 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2717 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;
2718
2719 //=== VK_KHR_object_refresh ===
2720
2721
2722 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2723 void refreshObjectsKHR( const VULKAN_HPP_NAMESPACE::RefreshObjectListKHR * pRefreshObjects, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2724 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2725 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2726 void refreshObjectsKHR( const VULKAN_HPP_NAMESPACE::RefreshObjectListKHR & refreshObjects, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2727 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2728
2729 //=== VK_KHR_synchronization2 ===
2730
2731
2732 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2733 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;
2734 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2735 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2736 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;
2737 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2738
2739
2740 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2741 void resetEvent2KHR( VULKAN_HPP_NAMESPACE::Event event, VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stageMask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2742
2743
2744 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2745 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;
2746 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2747 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2748 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;
2749 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2750
2751
2752 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2753 void pipelineBarrier2KHR( const VULKAN_HPP_NAMESPACE::DependencyInfo * pDependencyInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2754 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2755 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2756 void pipelineBarrier2KHR( const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2757 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2758
2759
2760 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2761 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;
2762
2763
2764 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2765 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;
2766
2767 //=== VK_KHR_copy_commands2 ===
2768
2769
2770 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2771 void copyBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 * pCopyBufferInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2772 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2773 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2774 void copyBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 & copyBufferInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2775 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2776
2777
2778 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2779 void copyImage2KHR( const VULKAN_HPP_NAMESPACE::CopyImageInfo2 * pCopyImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2780 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2781 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2782 void copyImage2KHR( const VULKAN_HPP_NAMESPACE::CopyImageInfo2 & copyImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2783 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2784
2785
2786 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2787 void copyBufferToImage2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 * pCopyBufferToImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2788 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2789 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2790 void copyBufferToImage2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 & copyBufferToImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2791 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2792
2793
2794 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2795 void copyImageToBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 * pCopyImageToBufferInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2796 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2797 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2798 void copyImageToBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 & copyImageToBufferInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2799 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2800
2801
2802 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2803 void blitImage2KHR( const VULKAN_HPP_NAMESPACE::BlitImageInfo2 * pBlitImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2804 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2805 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2806 void blitImage2KHR( const VULKAN_HPP_NAMESPACE::BlitImageInfo2 & blitImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2807 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2808
2809
2810 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2811 void resolveImage2KHR( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 * pResolveImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2812 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2813 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2814 void resolveImage2KHR( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 & resolveImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2815 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2816
2817 //=== VK_EXT_vertex_input_dynamic_state ===
2818
2819
2820 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2821 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;
2822 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2823 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2824 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;
2825 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2826
2827 //=== VK_EXT_extended_dynamic_state2 ===
2828
2829
2830 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2831 void setPatchControlPointsEXT( uint32_t patchControlPoints, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2832
2833
2834 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2835 void setRasterizerDiscardEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2836
2837
2838 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2839 void setDepthBiasEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2840
2841
2842 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2843 void setLogicOpEXT( VULKAN_HPP_NAMESPACE::LogicOp logicOp, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2844
2845
2846 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2847 void setPrimitiveRestartEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2848
2849 //=== VK_EXT_color_write_enable ===
2850
2851
2852 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2853 void setColorWriteEnableEXT( uint32_t attachmentCount, const VULKAN_HPP_NAMESPACE::Bool32 * pColorWriteEnables, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2854 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2855 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2856 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;
2857 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
2858
operator VkCommandBuffer() const2859 operator VkCommandBuffer() const VULKAN_HPP_NOEXCEPT
2860 {
2861 return m_commandBuffer;
2862 }
2863
operator bool() const2864 explicit operator bool() const VULKAN_HPP_NOEXCEPT
2865 {
2866 return m_commandBuffer != VK_NULL_HANDLE;
2867 }
2868
operator !() const2869 bool operator!() const VULKAN_HPP_NOEXCEPT
2870 {
2871 return m_commandBuffer == VK_NULL_HANDLE;
2872 }
2873
2874 private:
2875 VkCommandBuffer m_commandBuffer = {};
2876 };
2877
2878 template <>
2879 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCommandBuffer>
2880 {
2881 using Type = VULKAN_HPP_NAMESPACE::CommandBuffer;
2882 };
2883
2884
2885 template <>
2886 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandBuffer>
2887 {
2888 using Type = VULKAN_HPP_NAMESPACE::CommandBuffer;
2889 };
2890
2891
2892 template <>
2893 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CommandBuffer>
2894 {
2895 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2896 };
2897
2898 class DeviceMemory
2899 {
2900 public:
2901 using CType = VkDeviceMemory;
2902 using NativeType = VkDeviceMemory;
2903
2904 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDeviceMemory;
2905 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDeviceMemory;
2906
2907 public:
2908 VULKAN_HPP_CONSTEXPR DeviceMemory() = default;
DeviceMemory(std::nullptr_t)2909 VULKAN_HPP_CONSTEXPR DeviceMemory( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2910 {}
DeviceMemory(VkDeviceMemory deviceMemory)2911 VULKAN_HPP_TYPESAFE_EXPLICIT DeviceMemory( VkDeviceMemory deviceMemory ) VULKAN_HPP_NOEXCEPT
2912 : m_deviceMemory( deviceMemory )
2913 {}
2914
2915 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkDeviceMemory deviceMemory)2916 DeviceMemory & operator=(VkDeviceMemory deviceMemory) VULKAN_HPP_NOEXCEPT
2917 {
2918 m_deviceMemory = deviceMemory;
2919 return *this;
2920 }
2921 #endif
2922
operator =(std::nullptr_t)2923 DeviceMemory & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2924 {
2925 m_deviceMemory = {};
2926 return *this;
2927 }
2928
2929 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
2930 auto operator<=>( DeviceMemory const & ) const = default;
2931 #else
operator ==(DeviceMemory const & rhs) const2932 bool operator==( DeviceMemory const & rhs ) const VULKAN_HPP_NOEXCEPT
2933 {
2934 return m_deviceMemory == rhs.m_deviceMemory;
2935 }
2936
operator !=(DeviceMemory const & rhs) const2937 bool operator!=(DeviceMemory const & rhs ) const VULKAN_HPP_NOEXCEPT
2938 {
2939 return m_deviceMemory != rhs.m_deviceMemory;
2940 }
2941
operator <(DeviceMemory const & rhs) const2942 bool operator<(DeviceMemory const & rhs ) const VULKAN_HPP_NOEXCEPT
2943 {
2944 return m_deviceMemory < rhs.m_deviceMemory;
2945 }
2946 #endif
2947
operator VkDeviceMemory() const2948 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDeviceMemory() const VULKAN_HPP_NOEXCEPT
2949 {
2950 return m_deviceMemory;
2951 }
2952
operator bool() const2953 explicit operator bool() const VULKAN_HPP_NOEXCEPT
2954 {
2955 return m_deviceMemory != VK_NULL_HANDLE;
2956 }
2957
operator !() const2958 bool operator!() const VULKAN_HPP_NOEXCEPT
2959 {
2960 return m_deviceMemory == VK_NULL_HANDLE;
2961 }
2962
2963 private:
2964 VkDeviceMemory m_deviceMemory = {};
2965 };
2966
2967 template <>
2968 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDeviceMemory>
2969 {
2970 using Type = VULKAN_HPP_NAMESPACE::DeviceMemory;
2971 };
2972
2973
2974 template <>
2975 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDeviceMemory>
2976 {
2977 using Type = VULKAN_HPP_NAMESPACE::DeviceMemory;
2978 };
2979
2980
2981 template <>
2982 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DeviceMemory>
2983 {
2984 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2985 };
2986
2987 class BufferView
2988 {
2989 public:
2990 using CType = VkBufferView;
2991 using NativeType = VkBufferView;
2992
2993 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eBufferView;
2994 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferView;
2995
2996 public:
2997 VULKAN_HPP_CONSTEXPR BufferView() = default;
BufferView(std::nullptr_t)2998 VULKAN_HPP_CONSTEXPR BufferView( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2999 {}
BufferView(VkBufferView bufferView)3000 VULKAN_HPP_TYPESAFE_EXPLICIT BufferView( VkBufferView bufferView ) VULKAN_HPP_NOEXCEPT
3001 : m_bufferView( bufferView )
3002 {}
3003
3004 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkBufferView bufferView)3005 BufferView & operator=(VkBufferView bufferView) VULKAN_HPP_NOEXCEPT
3006 {
3007 m_bufferView = bufferView;
3008 return *this;
3009 }
3010 #endif
3011
operator =(std::nullptr_t)3012 BufferView & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3013 {
3014 m_bufferView = {};
3015 return *this;
3016 }
3017
3018 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
3019 auto operator<=>( BufferView const & ) const = default;
3020 #else
operator ==(BufferView const & rhs) const3021 bool operator==( BufferView const & rhs ) const VULKAN_HPP_NOEXCEPT
3022 {
3023 return m_bufferView == rhs.m_bufferView;
3024 }
3025
operator !=(BufferView const & rhs) const3026 bool operator!=(BufferView const & rhs ) const VULKAN_HPP_NOEXCEPT
3027 {
3028 return m_bufferView != rhs.m_bufferView;
3029 }
3030
operator <(BufferView const & rhs) const3031 bool operator<(BufferView const & rhs ) const VULKAN_HPP_NOEXCEPT
3032 {
3033 return m_bufferView < rhs.m_bufferView;
3034 }
3035 #endif
3036
operator VkBufferView() const3037 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBufferView() const VULKAN_HPP_NOEXCEPT
3038 {
3039 return m_bufferView;
3040 }
3041
operator bool() const3042 explicit operator bool() const VULKAN_HPP_NOEXCEPT
3043 {
3044 return m_bufferView != VK_NULL_HANDLE;
3045 }
3046
operator !() const3047 bool operator!() const VULKAN_HPP_NOEXCEPT
3048 {
3049 return m_bufferView == VK_NULL_HANDLE;
3050 }
3051
3052 private:
3053 VkBufferView m_bufferView = {};
3054 };
3055
3056 template <>
3057 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eBufferView>
3058 {
3059 using Type = VULKAN_HPP_NAMESPACE::BufferView;
3060 };
3061
3062
3063 template <>
3064 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferView>
3065 {
3066 using Type = VULKAN_HPP_NAMESPACE::BufferView;
3067 };
3068
3069
3070 template <>
3071 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::BufferView>
3072 {
3073 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3074 };
3075
3076 class CommandPool
3077 {
3078 public:
3079 using CType = VkCommandPool;
3080 using NativeType = VkCommandPool;
3081
3082 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCommandPool;
3083 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandPool;
3084
3085 public:
3086 VULKAN_HPP_CONSTEXPR CommandPool() = default;
CommandPool(std::nullptr_t)3087 VULKAN_HPP_CONSTEXPR CommandPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3088 {}
CommandPool(VkCommandPool commandPool)3089 VULKAN_HPP_TYPESAFE_EXPLICIT CommandPool( VkCommandPool commandPool ) VULKAN_HPP_NOEXCEPT
3090 : m_commandPool( commandPool )
3091 {}
3092
3093 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkCommandPool commandPool)3094 CommandPool & operator=(VkCommandPool commandPool) VULKAN_HPP_NOEXCEPT
3095 {
3096 m_commandPool = commandPool;
3097 return *this;
3098 }
3099 #endif
3100
operator =(std::nullptr_t)3101 CommandPool & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3102 {
3103 m_commandPool = {};
3104 return *this;
3105 }
3106
3107 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
3108 auto operator<=>( CommandPool const & ) const = default;
3109 #else
operator ==(CommandPool const & rhs) const3110 bool operator==( CommandPool const & rhs ) const VULKAN_HPP_NOEXCEPT
3111 {
3112 return m_commandPool == rhs.m_commandPool;
3113 }
3114
operator !=(CommandPool const & rhs) const3115 bool operator!=(CommandPool const & rhs ) const VULKAN_HPP_NOEXCEPT
3116 {
3117 return m_commandPool != rhs.m_commandPool;
3118 }
3119
operator <(CommandPool const & rhs) const3120 bool operator<(CommandPool const & rhs ) const VULKAN_HPP_NOEXCEPT
3121 {
3122 return m_commandPool < rhs.m_commandPool;
3123 }
3124 #endif
3125
operator VkCommandPool() const3126 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCommandPool() const VULKAN_HPP_NOEXCEPT
3127 {
3128 return m_commandPool;
3129 }
3130
operator bool() const3131 explicit operator bool() const VULKAN_HPP_NOEXCEPT
3132 {
3133 return m_commandPool != VK_NULL_HANDLE;
3134 }
3135
operator !() const3136 bool operator!() const VULKAN_HPP_NOEXCEPT
3137 {
3138 return m_commandPool == VK_NULL_HANDLE;
3139 }
3140
3141 private:
3142 VkCommandPool m_commandPool = {};
3143 };
3144
3145 template <>
3146 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCommandPool>
3147 {
3148 using Type = VULKAN_HPP_NAMESPACE::CommandPool;
3149 };
3150
3151
3152 template <>
3153 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandPool>
3154 {
3155 using Type = VULKAN_HPP_NAMESPACE::CommandPool;
3156 };
3157
3158
3159 template <>
3160 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CommandPool>
3161 {
3162 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3163 };
3164
3165 class PipelineCache
3166 {
3167 public:
3168 using CType = VkPipelineCache;
3169 using NativeType = VkPipelineCache;
3170
3171 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePipelineCache;
3172 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineCache;
3173
3174 public:
3175 VULKAN_HPP_CONSTEXPR PipelineCache() = default;
PipelineCache(std::nullptr_t)3176 VULKAN_HPP_CONSTEXPR PipelineCache( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3177 {}
PipelineCache(VkPipelineCache pipelineCache)3178 VULKAN_HPP_TYPESAFE_EXPLICIT PipelineCache( VkPipelineCache pipelineCache ) VULKAN_HPP_NOEXCEPT
3179 : m_pipelineCache( pipelineCache )
3180 {}
3181
3182 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkPipelineCache pipelineCache)3183 PipelineCache & operator=(VkPipelineCache pipelineCache) VULKAN_HPP_NOEXCEPT
3184 {
3185 m_pipelineCache = pipelineCache;
3186 return *this;
3187 }
3188 #endif
3189
operator =(std::nullptr_t)3190 PipelineCache & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3191 {
3192 m_pipelineCache = {};
3193 return *this;
3194 }
3195
3196 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
3197 auto operator<=>( PipelineCache const & ) const = default;
3198 #else
operator ==(PipelineCache const & rhs) const3199 bool operator==( PipelineCache const & rhs ) const VULKAN_HPP_NOEXCEPT
3200 {
3201 return m_pipelineCache == rhs.m_pipelineCache;
3202 }
3203
operator !=(PipelineCache const & rhs) const3204 bool operator!=(PipelineCache const & rhs ) const VULKAN_HPP_NOEXCEPT
3205 {
3206 return m_pipelineCache != rhs.m_pipelineCache;
3207 }
3208
operator <(PipelineCache const & rhs) const3209 bool operator<(PipelineCache const & rhs ) const VULKAN_HPP_NOEXCEPT
3210 {
3211 return m_pipelineCache < rhs.m_pipelineCache;
3212 }
3213 #endif
3214
operator VkPipelineCache() const3215 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineCache() const VULKAN_HPP_NOEXCEPT
3216 {
3217 return m_pipelineCache;
3218 }
3219
operator bool() const3220 explicit operator bool() const VULKAN_HPP_NOEXCEPT
3221 {
3222 return m_pipelineCache != VK_NULL_HANDLE;
3223 }
3224
operator !() const3225 bool operator!() const VULKAN_HPP_NOEXCEPT
3226 {
3227 return m_pipelineCache == VK_NULL_HANDLE;
3228 }
3229
3230 private:
3231 VkPipelineCache m_pipelineCache = {};
3232 };
3233
3234 template <>
3235 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePipelineCache>
3236 {
3237 using Type = VULKAN_HPP_NAMESPACE::PipelineCache;
3238 };
3239
3240
3241 template <>
3242 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineCache>
3243 {
3244 using Type = VULKAN_HPP_NAMESPACE::PipelineCache;
3245 };
3246
3247
3248 template <>
3249 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PipelineCache>
3250 {
3251 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3252 };
3253
3254 class DescriptorPool
3255 {
3256 public:
3257 using CType = VkDescriptorPool;
3258 using NativeType = VkDescriptorPool;
3259
3260 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorPool;
3261 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorPool;
3262
3263 public:
3264 VULKAN_HPP_CONSTEXPR DescriptorPool() = default;
DescriptorPool(std::nullptr_t)3265 VULKAN_HPP_CONSTEXPR DescriptorPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3266 {}
DescriptorPool(VkDescriptorPool descriptorPool)3267 VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorPool( VkDescriptorPool descriptorPool ) VULKAN_HPP_NOEXCEPT
3268 : m_descriptorPool( descriptorPool )
3269 {}
3270
3271 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkDescriptorPool descriptorPool)3272 DescriptorPool & operator=(VkDescriptorPool descriptorPool) VULKAN_HPP_NOEXCEPT
3273 {
3274 m_descriptorPool = descriptorPool;
3275 return *this;
3276 }
3277 #endif
3278
operator =(std::nullptr_t)3279 DescriptorPool & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3280 {
3281 m_descriptorPool = {};
3282 return *this;
3283 }
3284
3285 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
3286 auto operator<=>( DescriptorPool const & ) const = default;
3287 #else
operator ==(DescriptorPool const & rhs) const3288 bool operator==( DescriptorPool const & rhs ) const VULKAN_HPP_NOEXCEPT
3289 {
3290 return m_descriptorPool == rhs.m_descriptorPool;
3291 }
3292
operator !=(DescriptorPool const & rhs) const3293 bool operator!=(DescriptorPool const & rhs ) const VULKAN_HPP_NOEXCEPT
3294 {
3295 return m_descriptorPool != rhs.m_descriptorPool;
3296 }
3297
operator <(DescriptorPool const & rhs) const3298 bool operator<(DescriptorPool const & rhs ) const VULKAN_HPP_NOEXCEPT
3299 {
3300 return m_descriptorPool < rhs.m_descriptorPool;
3301 }
3302 #endif
3303
operator VkDescriptorPool() const3304 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorPool() const VULKAN_HPP_NOEXCEPT
3305 {
3306 return m_descriptorPool;
3307 }
3308
operator bool() const3309 explicit operator bool() const VULKAN_HPP_NOEXCEPT
3310 {
3311 return m_descriptorPool != VK_NULL_HANDLE;
3312 }
3313
operator !() const3314 bool operator!() const VULKAN_HPP_NOEXCEPT
3315 {
3316 return m_descriptorPool == VK_NULL_HANDLE;
3317 }
3318
3319 private:
3320 VkDescriptorPool m_descriptorPool = {};
3321 };
3322
3323 template <>
3324 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorPool>
3325 {
3326 using Type = VULKAN_HPP_NAMESPACE::DescriptorPool;
3327 };
3328
3329
3330 template <>
3331 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorPool>
3332 {
3333 using Type = VULKAN_HPP_NAMESPACE::DescriptorPool;
3334 };
3335
3336
3337 template <>
3338 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DescriptorPool>
3339 {
3340 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3341 };
3342
3343 class DescriptorSetLayout
3344 {
3345 public:
3346 using CType = VkDescriptorSetLayout;
3347 using NativeType = VkDescriptorSetLayout;
3348
3349 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSetLayout;
3350 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSetLayout;
3351
3352 public:
3353 VULKAN_HPP_CONSTEXPR DescriptorSetLayout() = default;
DescriptorSetLayout(std::nullptr_t)3354 VULKAN_HPP_CONSTEXPR DescriptorSetLayout( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3355 {}
DescriptorSetLayout(VkDescriptorSetLayout descriptorSetLayout)3356 VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSetLayout( VkDescriptorSetLayout descriptorSetLayout ) VULKAN_HPP_NOEXCEPT
3357 : m_descriptorSetLayout( descriptorSetLayout )
3358 {}
3359
3360 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkDescriptorSetLayout descriptorSetLayout)3361 DescriptorSetLayout & operator=(VkDescriptorSetLayout descriptorSetLayout) VULKAN_HPP_NOEXCEPT
3362 {
3363 m_descriptorSetLayout = descriptorSetLayout;
3364 return *this;
3365 }
3366 #endif
3367
operator =(std::nullptr_t)3368 DescriptorSetLayout & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3369 {
3370 m_descriptorSetLayout = {};
3371 return *this;
3372 }
3373
3374 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
3375 auto operator<=>( DescriptorSetLayout const & ) const = default;
3376 #else
operator ==(DescriptorSetLayout const & rhs) const3377 bool operator==( DescriptorSetLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
3378 {
3379 return m_descriptorSetLayout == rhs.m_descriptorSetLayout;
3380 }
3381
operator !=(DescriptorSetLayout const & rhs) const3382 bool operator!=(DescriptorSetLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
3383 {
3384 return m_descriptorSetLayout != rhs.m_descriptorSetLayout;
3385 }
3386
operator <(DescriptorSetLayout const & rhs) const3387 bool operator<(DescriptorSetLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
3388 {
3389 return m_descriptorSetLayout < rhs.m_descriptorSetLayout;
3390 }
3391 #endif
3392
operator VkDescriptorSetLayout() const3393 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorSetLayout() const VULKAN_HPP_NOEXCEPT
3394 {
3395 return m_descriptorSetLayout;
3396 }
3397
operator bool() const3398 explicit operator bool() const VULKAN_HPP_NOEXCEPT
3399 {
3400 return m_descriptorSetLayout != VK_NULL_HANDLE;
3401 }
3402
operator !() const3403 bool operator!() const VULKAN_HPP_NOEXCEPT
3404 {
3405 return m_descriptorSetLayout == VK_NULL_HANDLE;
3406 }
3407
3408 private:
3409 VkDescriptorSetLayout m_descriptorSetLayout = {};
3410 };
3411
3412 template <>
3413 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSetLayout>
3414 {
3415 using Type = VULKAN_HPP_NAMESPACE::DescriptorSetLayout;
3416 };
3417
3418
3419 template <>
3420 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSetLayout>
3421 {
3422 using Type = VULKAN_HPP_NAMESPACE::DescriptorSetLayout;
3423 };
3424
3425
3426 template <>
3427 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DescriptorSetLayout>
3428 {
3429 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3430 };
3431
3432 class Framebuffer
3433 {
3434 public:
3435 using CType = VkFramebuffer;
3436 using NativeType = VkFramebuffer;
3437
3438 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eFramebuffer;
3439 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFramebuffer;
3440
3441 public:
3442 VULKAN_HPP_CONSTEXPR Framebuffer() = default;
Framebuffer(std::nullptr_t)3443 VULKAN_HPP_CONSTEXPR Framebuffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3444 {}
Framebuffer(VkFramebuffer framebuffer)3445 VULKAN_HPP_TYPESAFE_EXPLICIT Framebuffer( VkFramebuffer framebuffer ) VULKAN_HPP_NOEXCEPT
3446 : m_framebuffer( framebuffer )
3447 {}
3448
3449 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkFramebuffer framebuffer)3450 Framebuffer & operator=(VkFramebuffer framebuffer) VULKAN_HPP_NOEXCEPT
3451 {
3452 m_framebuffer = framebuffer;
3453 return *this;
3454 }
3455 #endif
3456
operator =(std::nullptr_t)3457 Framebuffer & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3458 {
3459 m_framebuffer = {};
3460 return *this;
3461 }
3462
3463 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
3464 auto operator<=>( Framebuffer const & ) const = default;
3465 #else
operator ==(Framebuffer const & rhs) const3466 bool operator==( Framebuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
3467 {
3468 return m_framebuffer == rhs.m_framebuffer;
3469 }
3470
operator !=(Framebuffer const & rhs) const3471 bool operator!=(Framebuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
3472 {
3473 return m_framebuffer != rhs.m_framebuffer;
3474 }
3475
operator <(Framebuffer const & rhs) const3476 bool operator<(Framebuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
3477 {
3478 return m_framebuffer < rhs.m_framebuffer;
3479 }
3480 #endif
3481
operator VkFramebuffer() const3482 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkFramebuffer() const VULKAN_HPP_NOEXCEPT
3483 {
3484 return m_framebuffer;
3485 }
3486
operator bool() const3487 explicit operator bool() const VULKAN_HPP_NOEXCEPT
3488 {
3489 return m_framebuffer != VK_NULL_HANDLE;
3490 }
3491
operator !() const3492 bool operator!() const VULKAN_HPP_NOEXCEPT
3493 {
3494 return m_framebuffer == VK_NULL_HANDLE;
3495 }
3496
3497 private:
3498 VkFramebuffer m_framebuffer = {};
3499 };
3500
3501 template <>
3502 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eFramebuffer>
3503 {
3504 using Type = VULKAN_HPP_NAMESPACE::Framebuffer;
3505 };
3506
3507
3508 template <>
3509 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFramebuffer>
3510 {
3511 using Type = VULKAN_HPP_NAMESPACE::Framebuffer;
3512 };
3513
3514
3515 template <>
3516 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Framebuffer>
3517 {
3518 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3519 };
3520
3521 class ImageView
3522 {
3523 public:
3524 using CType = VkImageView;
3525 using NativeType = VkImageView;
3526
3527 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eImageView;
3528 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImageView;
3529
3530 public:
3531 VULKAN_HPP_CONSTEXPR ImageView() = default;
ImageView(std::nullptr_t)3532 VULKAN_HPP_CONSTEXPR ImageView( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3533 {}
ImageView(VkImageView imageView)3534 VULKAN_HPP_TYPESAFE_EXPLICIT ImageView( VkImageView imageView ) VULKAN_HPP_NOEXCEPT
3535 : m_imageView( imageView )
3536 {}
3537
3538 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkImageView imageView)3539 ImageView & operator=(VkImageView imageView) VULKAN_HPP_NOEXCEPT
3540 {
3541 m_imageView = imageView;
3542 return *this;
3543 }
3544 #endif
3545
operator =(std::nullptr_t)3546 ImageView & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3547 {
3548 m_imageView = {};
3549 return *this;
3550 }
3551
3552 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
3553 auto operator<=>( ImageView const & ) const = default;
3554 #else
operator ==(ImageView const & rhs) const3555 bool operator==( ImageView const & rhs ) const VULKAN_HPP_NOEXCEPT
3556 {
3557 return m_imageView == rhs.m_imageView;
3558 }
3559
operator !=(ImageView const & rhs) const3560 bool operator!=(ImageView const & rhs ) const VULKAN_HPP_NOEXCEPT
3561 {
3562 return m_imageView != rhs.m_imageView;
3563 }
3564
operator <(ImageView const & rhs) const3565 bool operator<(ImageView const & rhs ) const VULKAN_HPP_NOEXCEPT
3566 {
3567 return m_imageView < rhs.m_imageView;
3568 }
3569 #endif
3570
operator VkImageView() const3571 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkImageView() const VULKAN_HPP_NOEXCEPT
3572 {
3573 return m_imageView;
3574 }
3575
operator bool() const3576 explicit operator bool() const VULKAN_HPP_NOEXCEPT
3577 {
3578 return m_imageView != VK_NULL_HANDLE;
3579 }
3580
operator !() const3581 bool operator!() const VULKAN_HPP_NOEXCEPT
3582 {
3583 return m_imageView == VK_NULL_HANDLE;
3584 }
3585
3586 private:
3587 VkImageView m_imageView = {};
3588 };
3589
3590 template <>
3591 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eImageView>
3592 {
3593 using Type = VULKAN_HPP_NAMESPACE::ImageView;
3594 };
3595
3596
3597 template <>
3598 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImageView>
3599 {
3600 using Type = VULKAN_HPP_NAMESPACE::ImageView;
3601 };
3602
3603
3604 template <>
3605 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::ImageView>
3606 {
3607 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3608 };
3609
3610 class PrivateDataSlot
3611 {
3612 public:
3613 using CType = VkPrivateDataSlot;
3614 using NativeType = VkPrivateDataSlot;
3615
3616 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePrivateDataSlot;
3617 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
3618
3619 public:
3620 VULKAN_HPP_CONSTEXPR PrivateDataSlot() = default;
PrivateDataSlot(std::nullptr_t)3621 VULKAN_HPP_CONSTEXPR PrivateDataSlot( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3622 {}
PrivateDataSlot(VkPrivateDataSlot privateDataSlot)3623 VULKAN_HPP_TYPESAFE_EXPLICIT PrivateDataSlot( VkPrivateDataSlot privateDataSlot ) VULKAN_HPP_NOEXCEPT
3624 : m_privateDataSlot( privateDataSlot )
3625 {}
3626
3627 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkPrivateDataSlot privateDataSlot)3628 PrivateDataSlot & operator=(VkPrivateDataSlot privateDataSlot) VULKAN_HPP_NOEXCEPT
3629 {
3630 m_privateDataSlot = privateDataSlot;
3631 return *this;
3632 }
3633 #endif
3634
operator =(std::nullptr_t)3635 PrivateDataSlot & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3636 {
3637 m_privateDataSlot = {};
3638 return *this;
3639 }
3640
3641 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
3642 auto operator<=>( PrivateDataSlot const & ) const = default;
3643 #else
operator ==(PrivateDataSlot const & rhs) const3644 bool operator==( PrivateDataSlot const & rhs ) const VULKAN_HPP_NOEXCEPT
3645 {
3646 return m_privateDataSlot == rhs.m_privateDataSlot;
3647 }
3648
operator !=(PrivateDataSlot const & rhs) const3649 bool operator!=(PrivateDataSlot const & rhs ) const VULKAN_HPP_NOEXCEPT
3650 {
3651 return m_privateDataSlot != rhs.m_privateDataSlot;
3652 }
3653
operator <(PrivateDataSlot const & rhs) const3654 bool operator<(PrivateDataSlot const & rhs ) const VULKAN_HPP_NOEXCEPT
3655 {
3656 return m_privateDataSlot < rhs.m_privateDataSlot;
3657 }
3658 #endif
3659
operator VkPrivateDataSlot() const3660 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPrivateDataSlot() const VULKAN_HPP_NOEXCEPT
3661 {
3662 return m_privateDataSlot;
3663 }
3664
operator bool() const3665 explicit operator bool() const VULKAN_HPP_NOEXCEPT
3666 {
3667 return m_privateDataSlot != VK_NULL_HANDLE;
3668 }
3669
operator !() const3670 bool operator!() const VULKAN_HPP_NOEXCEPT
3671 {
3672 return m_privateDataSlot == VK_NULL_HANDLE;
3673 }
3674
3675 private:
3676 VkPrivateDataSlot m_privateDataSlot = {};
3677 };
3678
3679 template <>
3680 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePrivateDataSlot>
3681 {
3682 using Type = VULKAN_HPP_NAMESPACE::PrivateDataSlot;
3683 };
3684
3685
3686
3687 template <>
3688 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PrivateDataSlot>
3689 {
3690 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3691 };
3692 using PrivateDataSlotEXT = PrivateDataSlot;
3693
3694 class RenderPass
3695 {
3696 public:
3697 using CType = VkRenderPass;
3698 using NativeType = VkRenderPass;
3699
3700 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eRenderPass;
3701 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eRenderPass;
3702
3703 public:
3704 VULKAN_HPP_CONSTEXPR RenderPass() = default;
RenderPass(std::nullptr_t)3705 VULKAN_HPP_CONSTEXPR RenderPass( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3706 {}
RenderPass(VkRenderPass renderPass)3707 VULKAN_HPP_TYPESAFE_EXPLICIT RenderPass( VkRenderPass renderPass ) VULKAN_HPP_NOEXCEPT
3708 : m_renderPass( renderPass )
3709 {}
3710
3711 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkRenderPass renderPass)3712 RenderPass & operator=(VkRenderPass renderPass) VULKAN_HPP_NOEXCEPT
3713 {
3714 m_renderPass = renderPass;
3715 return *this;
3716 }
3717 #endif
3718
operator =(std::nullptr_t)3719 RenderPass & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3720 {
3721 m_renderPass = {};
3722 return *this;
3723 }
3724
3725 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
3726 auto operator<=>( RenderPass const & ) const = default;
3727 #else
operator ==(RenderPass const & rhs) const3728 bool operator==( RenderPass const & rhs ) const VULKAN_HPP_NOEXCEPT
3729 {
3730 return m_renderPass == rhs.m_renderPass;
3731 }
3732
operator !=(RenderPass const & rhs) const3733 bool operator!=(RenderPass const & rhs ) const VULKAN_HPP_NOEXCEPT
3734 {
3735 return m_renderPass != rhs.m_renderPass;
3736 }
3737
operator <(RenderPass const & rhs) const3738 bool operator<(RenderPass const & rhs ) const VULKAN_HPP_NOEXCEPT
3739 {
3740 return m_renderPass < rhs.m_renderPass;
3741 }
3742 #endif
3743
operator VkRenderPass() const3744 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkRenderPass() const VULKAN_HPP_NOEXCEPT
3745 {
3746 return m_renderPass;
3747 }
3748
operator bool() const3749 explicit operator bool() const VULKAN_HPP_NOEXCEPT
3750 {
3751 return m_renderPass != VK_NULL_HANDLE;
3752 }
3753
operator !() const3754 bool operator!() const VULKAN_HPP_NOEXCEPT
3755 {
3756 return m_renderPass == VK_NULL_HANDLE;
3757 }
3758
3759 private:
3760 VkRenderPass m_renderPass = {};
3761 };
3762
3763 template <>
3764 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eRenderPass>
3765 {
3766 using Type = VULKAN_HPP_NAMESPACE::RenderPass;
3767 };
3768
3769
3770 template <>
3771 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eRenderPass>
3772 {
3773 using Type = VULKAN_HPP_NAMESPACE::RenderPass;
3774 };
3775
3776
3777 template <>
3778 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::RenderPass>
3779 {
3780 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3781 };
3782
3783 class Sampler
3784 {
3785 public:
3786 using CType = VkSampler;
3787 using NativeType = VkSampler;
3788
3789 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSampler;
3790 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSampler;
3791
3792 public:
3793 VULKAN_HPP_CONSTEXPR Sampler() = default;
Sampler(std::nullptr_t)3794 VULKAN_HPP_CONSTEXPR Sampler( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3795 {}
Sampler(VkSampler sampler)3796 VULKAN_HPP_TYPESAFE_EXPLICIT Sampler( VkSampler sampler ) VULKAN_HPP_NOEXCEPT
3797 : m_sampler( sampler )
3798 {}
3799
3800 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkSampler sampler)3801 Sampler & operator=(VkSampler sampler) VULKAN_HPP_NOEXCEPT
3802 {
3803 m_sampler = sampler;
3804 return *this;
3805 }
3806 #endif
3807
operator =(std::nullptr_t)3808 Sampler & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3809 {
3810 m_sampler = {};
3811 return *this;
3812 }
3813
3814 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
3815 auto operator<=>( Sampler const & ) const = default;
3816 #else
operator ==(Sampler const & rhs) const3817 bool operator==( Sampler const & rhs ) const VULKAN_HPP_NOEXCEPT
3818 {
3819 return m_sampler == rhs.m_sampler;
3820 }
3821
operator !=(Sampler const & rhs) const3822 bool operator!=(Sampler const & rhs ) const VULKAN_HPP_NOEXCEPT
3823 {
3824 return m_sampler != rhs.m_sampler;
3825 }
3826
operator <(Sampler const & rhs) const3827 bool operator<(Sampler const & rhs ) const VULKAN_HPP_NOEXCEPT
3828 {
3829 return m_sampler < rhs.m_sampler;
3830 }
3831 #endif
3832
operator VkSampler() const3833 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSampler() const VULKAN_HPP_NOEXCEPT
3834 {
3835 return m_sampler;
3836 }
3837
operator bool() const3838 explicit operator bool() const VULKAN_HPP_NOEXCEPT
3839 {
3840 return m_sampler != VK_NULL_HANDLE;
3841 }
3842
operator !() const3843 bool operator!() const VULKAN_HPP_NOEXCEPT
3844 {
3845 return m_sampler == VK_NULL_HANDLE;
3846 }
3847
3848 private:
3849 VkSampler m_sampler = {};
3850 };
3851
3852 template <>
3853 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSampler>
3854 {
3855 using Type = VULKAN_HPP_NAMESPACE::Sampler;
3856 };
3857
3858
3859 template <>
3860 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSampler>
3861 {
3862 using Type = VULKAN_HPP_NAMESPACE::Sampler;
3863 };
3864
3865
3866 template <>
3867 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Sampler>
3868 {
3869 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3870 };
3871
3872 class SamplerYcbcrConversion
3873 {
3874 public:
3875 using CType = VkSamplerYcbcrConversion;
3876 using NativeType = VkSamplerYcbcrConversion;
3877
3878 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSamplerYcbcrConversion;
3879 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
3880
3881 public:
3882 VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion() = default;
SamplerYcbcrConversion(std::nullptr_t)3883 VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3884 {}
SamplerYcbcrConversion(VkSamplerYcbcrConversion samplerYcbcrConversion)3885 VULKAN_HPP_TYPESAFE_EXPLICIT SamplerYcbcrConversion( VkSamplerYcbcrConversion samplerYcbcrConversion ) VULKAN_HPP_NOEXCEPT
3886 : m_samplerYcbcrConversion( samplerYcbcrConversion )
3887 {}
3888
3889 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkSamplerYcbcrConversion samplerYcbcrConversion)3890 SamplerYcbcrConversion & operator=(VkSamplerYcbcrConversion samplerYcbcrConversion) VULKAN_HPP_NOEXCEPT
3891 {
3892 m_samplerYcbcrConversion = samplerYcbcrConversion;
3893 return *this;
3894 }
3895 #endif
3896
operator =(std::nullptr_t)3897 SamplerYcbcrConversion & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3898 {
3899 m_samplerYcbcrConversion = {};
3900 return *this;
3901 }
3902
3903 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
3904 auto operator<=>( SamplerYcbcrConversion const & ) const = default;
3905 #else
operator ==(SamplerYcbcrConversion const & rhs) const3906 bool operator==( SamplerYcbcrConversion const & rhs ) const VULKAN_HPP_NOEXCEPT
3907 {
3908 return m_samplerYcbcrConversion == rhs.m_samplerYcbcrConversion;
3909 }
3910
operator !=(SamplerYcbcrConversion const & rhs) const3911 bool operator!=(SamplerYcbcrConversion const & rhs ) const VULKAN_HPP_NOEXCEPT
3912 {
3913 return m_samplerYcbcrConversion != rhs.m_samplerYcbcrConversion;
3914 }
3915
operator <(SamplerYcbcrConversion const & rhs) const3916 bool operator<(SamplerYcbcrConversion const & rhs ) const VULKAN_HPP_NOEXCEPT
3917 {
3918 return m_samplerYcbcrConversion < rhs.m_samplerYcbcrConversion;
3919 }
3920 #endif
3921
operator VkSamplerYcbcrConversion() const3922 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSamplerYcbcrConversion() const VULKAN_HPP_NOEXCEPT
3923 {
3924 return m_samplerYcbcrConversion;
3925 }
3926
operator bool() const3927 explicit operator bool() const VULKAN_HPP_NOEXCEPT
3928 {
3929 return m_samplerYcbcrConversion != VK_NULL_HANDLE;
3930 }
3931
operator !() const3932 bool operator!() const VULKAN_HPP_NOEXCEPT
3933 {
3934 return m_samplerYcbcrConversion == VK_NULL_HANDLE;
3935 }
3936
3937 private:
3938 VkSamplerYcbcrConversion m_samplerYcbcrConversion = {};
3939 };
3940
3941 template <>
3942 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSamplerYcbcrConversion>
3943 {
3944 using Type = VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion;
3945 };
3946
3947
3948
3949 template <>
3950 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>
3951 {
3952 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3953 };
3954 using SamplerYcbcrConversionKHR = SamplerYcbcrConversion;
3955
3956 #if defined( VK_USE_PLATFORM_SCI )
3957 class SemaphoreSciSyncPoolNV
3958 {
3959 public:
3960 using CType = VkSemaphoreSciSyncPoolNV;
3961 using NativeType = VkSemaphoreSciSyncPoolNV;
3962
3963 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSemaphoreSciSyncPoolNV;
3964 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
3965
3966 public:
3967 VULKAN_HPP_CONSTEXPR SemaphoreSciSyncPoolNV() = default;
SemaphoreSciSyncPoolNV(std::nullptr_t)3968 VULKAN_HPP_CONSTEXPR SemaphoreSciSyncPoolNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3969 {}
SemaphoreSciSyncPoolNV(VkSemaphoreSciSyncPoolNV semaphoreSciSyncPoolNV)3970 VULKAN_HPP_TYPESAFE_EXPLICIT SemaphoreSciSyncPoolNV( VkSemaphoreSciSyncPoolNV semaphoreSciSyncPoolNV ) VULKAN_HPP_NOEXCEPT
3971 : m_semaphoreSciSyncPoolNV( semaphoreSciSyncPoolNV )
3972 {}
3973
3974 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkSemaphoreSciSyncPoolNV semaphoreSciSyncPoolNV)3975 SemaphoreSciSyncPoolNV & operator=(VkSemaphoreSciSyncPoolNV semaphoreSciSyncPoolNV) VULKAN_HPP_NOEXCEPT
3976 {
3977 m_semaphoreSciSyncPoolNV = semaphoreSciSyncPoolNV;
3978 return *this;
3979 }
3980 #endif
3981
operator =(std::nullptr_t)3982 SemaphoreSciSyncPoolNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3983 {
3984 m_semaphoreSciSyncPoolNV = {};
3985 return *this;
3986 }
3987
3988 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
3989 auto operator<=>( SemaphoreSciSyncPoolNV const & ) const = default;
3990 #else
operator ==(SemaphoreSciSyncPoolNV const & rhs) const3991 bool operator==( SemaphoreSciSyncPoolNV const & rhs ) const VULKAN_HPP_NOEXCEPT
3992 {
3993 return m_semaphoreSciSyncPoolNV == rhs.m_semaphoreSciSyncPoolNV;
3994 }
3995
operator !=(SemaphoreSciSyncPoolNV const & rhs) const3996 bool operator!=(SemaphoreSciSyncPoolNV const & rhs ) const VULKAN_HPP_NOEXCEPT
3997 {
3998 return m_semaphoreSciSyncPoolNV != rhs.m_semaphoreSciSyncPoolNV;
3999 }
4000
operator <(SemaphoreSciSyncPoolNV const & rhs) const4001 bool operator<(SemaphoreSciSyncPoolNV const & rhs ) const VULKAN_HPP_NOEXCEPT
4002 {
4003 return m_semaphoreSciSyncPoolNV < rhs.m_semaphoreSciSyncPoolNV;
4004 }
4005 #endif
4006
operator VkSemaphoreSciSyncPoolNV() const4007 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSemaphoreSciSyncPoolNV() const VULKAN_HPP_NOEXCEPT
4008 {
4009 return m_semaphoreSciSyncPoolNV;
4010 }
4011
operator bool() const4012 explicit operator bool() const VULKAN_HPP_NOEXCEPT
4013 {
4014 return m_semaphoreSciSyncPoolNV != VK_NULL_HANDLE;
4015 }
4016
operator !() const4017 bool operator!() const VULKAN_HPP_NOEXCEPT
4018 {
4019 return m_semaphoreSciSyncPoolNV == VK_NULL_HANDLE;
4020 }
4021
4022 private:
4023 VkSemaphoreSciSyncPoolNV m_semaphoreSciSyncPoolNV = {};
4024 };
4025
4026 template <>
4027 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSemaphoreSciSyncPoolNV>
4028 {
4029 using Type = VULKAN_HPP_NAMESPACE::SemaphoreSciSyncPoolNV;
4030 };
4031
4032
4033
4034 template <>
4035 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::SemaphoreSciSyncPoolNV>
4036 {
4037 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
4038 };
4039 #endif /*VK_USE_PLATFORM_SCI*/
4040
4041 class DisplayKHR
4042 {
4043 public:
4044 using CType = VkDisplayKHR;
4045 using NativeType = VkDisplayKHR;
4046
4047 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDisplayKHR;
4048 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayKHR;
4049
4050 public:
4051 VULKAN_HPP_CONSTEXPR DisplayKHR() = default;
DisplayKHR(std::nullptr_t)4052 VULKAN_HPP_CONSTEXPR DisplayKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
4053 {}
DisplayKHR(VkDisplayKHR displayKHR)4054 VULKAN_HPP_TYPESAFE_EXPLICIT DisplayKHR( VkDisplayKHR displayKHR ) VULKAN_HPP_NOEXCEPT
4055 : m_displayKHR( displayKHR )
4056 {}
4057
4058 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkDisplayKHR displayKHR)4059 DisplayKHR & operator=(VkDisplayKHR displayKHR) VULKAN_HPP_NOEXCEPT
4060 {
4061 m_displayKHR = displayKHR;
4062 return *this;
4063 }
4064 #endif
4065
operator =(std::nullptr_t)4066 DisplayKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
4067 {
4068 m_displayKHR = {};
4069 return *this;
4070 }
4071
4072 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
4073 auto operator<=>( DisplayKHR const & ) const = default;
4074 #else
operator ==(DisplayKHR const & rhs) const4075 bool operator==( DisplayKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
4076 {
4077 return m_displayKHR == rhs.m_displayKHR;
4078 }
4079
operator !=(DisplayKHR const & rhs) const4080 bool operator!=(DisplayKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
4081 {
4082 return m_displayKHR != rhs.m_displayKHR;
4083 }
4084
operator <(DisplayKHR const & rhs) const4085 bool operator<(DisplayKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
4086 {
4087 return m_displayKHR < rhs.m_displayKHR;
4088 }
4089 #endif
4090
operator VkDisplayKHR() const4091 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDisplayKHR() const VULKAN_HPP_NOEXCEPT
4092 {
4093 return m_displayKHR;
4094 }
4095
operator bool() const4096 explicit operator bool() const VULKAN_HPP_NOEXCEPT
4097 {
4098 return m_displayKHR != VK_NULL_HANDLE;
4099 }
4100
operator !() const4101 bool operator!() const VULKAN_HPP_NOEXCEPT
4102 {
4103 return m_displayKHR == VK_NULL_HANDLE;
4104 }
4105
4106 private:
4107 VkDisplayKHR m_displayKHR = {};
4108 };
4109
4110 template <>
4111 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDisplayKHR>
4112 {
4113 using Type = VULKAN_HPP_NAMESPACE::DisplayKHR;
4114 };
4115
4116
4117 template <>
4118 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayKHR>
4119 {
4120 using Type = VULKAN_HPP_NAMESPACE::DisplayKHR;
4121 };
4122
4123
4124 template <>
4125 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DisplayKHR>
4126 {
4127 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
4128 };
4129
4130 class Queue
4131 {
4132 public:
4133 using CType = VkQueue;
4134 using NativeType = VkQueue;
4135
4136 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eQueue;
4137 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueue;
4138
4139 public:
4140 VULKAN_HPP_CONSTEXPR Queue() = default;
Queue(std::nullptr_t)4141 VULKAN_HPP_CONSTEXPR Queue( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
4142 {}
Queue(VkQueue queue)4143 Queue( VkQueue queue ) VULKAN_HPP_NOEXCEPT
4144 : m_queue( queue )
4145 {}
4146
operator =(VkQueue queue)4147 Queue & operator=(VkQueue queue) VULKAN_HPP_NOEXCEPT
4148 {
4149 m_queue = queue;
4150 return *this;
4151 }
4152
operator =(std::nullptr_t)4153 Queue & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
4154 {
4155 m_queue = {};
4156 return *this;
4157 }
4158
4159 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
4160 auto operator<=>( Queue const & ) const = default;
4161 #else
operator ==(Queue const & rhs) const4162 bool operator==( Queue const & rhs ) const VULKAN_HPP_NOEXCEPT
4163 {
4164 return m_queue == rhs.m_queue;
4165 }
4166
operator !=(Queue const & rhs) const4167 bool operator!=(Queue const & rhs ) const VULKAN_HPP_NOEXCEPT
4168 {
4169 return m_queue != rhs.m_queue;
4170 }
4171
operator <(Queue const & rhs) const4172 bool operator<(Queue const & rhs ) const VULKAN_HPP_NOEXCEPT
4173 {
4174 return m_queue < rhs.m_queue;
4175 }
4176 #endif
4177
4178 //=== VK_VERSION_1_0 ===
4179
4180
4181 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4182 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;
4183 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4184 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4185 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;
4186 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4187
4188
4189 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
4190 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4191 VULKAN_HPP_NODISCARD Result waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4192 #else
4193 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4194 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
4195 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4196
4197 //=== VK_VERSION_1_3 ===
4198
4199
4200 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4201 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;
4202 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4203 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4204 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;
4205 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4206
4207 //=== VK_KHR_swapchain ===
4208
4209
4210 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4211 VULKAN_HPP_NODISCARD Result presentKHR( const VULKAN_HPP_NAMESPACE::PresentInfoKHR * pPresentInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4212 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4213 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4214 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result presentKHR( const VULKAN_HPP_NAMESPACE::PresentInfoKHR & presentInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
4215 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4216
4217 //=== VK_EXT_debug_utils ===
4218
4219
4220 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4221 void beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4222 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4223 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4224 void beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4225 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4226
4227
4228 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4229 void endDebugUtilsLabelEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4230
4231
4232 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4233 void insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo, 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 insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4237 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4238
4239 //=== VK_KHR_synchronization2 ===
4240
4241
4242 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4243 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;
4244 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4245 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4246 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;
4247 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4248
4249
4250 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4251 void getCheckpointData2NV( uint32_t * pCheckpointDataCount, VULKAN_HPP_NAMESPACE::CheckpointData2NV * pCheckpointData, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4252 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4253 template <typename CheckpointData2NVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CheckpointData2NV>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4254 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CheckpointData2NV, CheckpointData2NVAllocator> getCheckpointData2NV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
4255 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>
4256 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CheckpointData2NV, CheckpointData2NVAllocator> getCheckpointData2NV( CheckpointData2NVAllocator & checkpointData2NVAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
4257 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4258
operator VkQueue() const4259 operator VkQueue() const VULKAN_HPP_NOEXCEPT
4260 {
4261 return m_queue;
4262 }
4263
operator bool() const4264 explicit operator bool() const VULKAN_HPP_NOEXCEPT
4265 {
4266 return m_queue != VK_NULL_HANDLE;
4267 }
4268
operator !() const4269 bool operator!() const VULKAN_HPP_NOEXCEPT
4270 {
4271 return m_queue == VK_NULL_HANDLE;
4272 }
4273
4274 private:
4275 VkQueue m_queue = {};
4276 };
4277
4278 template <>
4279 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eQueue>
4280 {
4281 using Type = VULKAN_HPP_NAMESPACE::Queue;
4282 };
4283
4284
4285 template <>
4286 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueue>
4287 {
4288 using Type = VULKAN_HPP_NAMESPACE::Queue;
4289 };
4290
4291
4292 template <>
4293 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Queue>
4294 {
4295 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
4296 };
4297
4298 class Device
4299 {
4300 public:
4301 using CType = VkDevice;
4302 using NativeType = VkDevice;
4303
4304 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDevice;
4305 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDevice;
4306
4307 public:
4308 VULKAN_HPP_CONSTEXPR Device() = default;
Device(std::nullptr_t)4309 VULKAN_HPP_CONSTEXPR Device( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
4310 {}
Device(VkDevice device)4311 Device( VkDevice device ) VULKAN_HPP_NOEXCEPT
4312 : m_device( device )
4313 {}
4314
operator =(VkDevice device)4315 Device & operator=(VkDevice device) VULKAN_HPP_NOEXCEPT
4316 {
4317 m_device = device;
4318 return *this;
4319 }
4320
operator =(std::nullptr_t)4321 Device & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
4322 {
4323 m_device = {};
4324 return *this;
4325 }
4326
4327 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
4328 auto operator<=>( Device const & ) const = default;
4329 #else
operator ==(Device const & rhs) const4330 bool operator==( Device const & rhs ) const VULKAN_HPP_NOEXCEPT
4331 {
4332 return m_device == rhs.m_device;
4333 }
4334
operator !=(Device const & rhs) const4335 bool operator!=(Device const & rhs ) const VULKAN_HPP_NOEXCEPT
4336 {
4337 return m_device != rhs.m_device;
4338 }
4339
operator <(Device const & rhs) const4340 bool operator<(Device const & rhs ) const VULKAN_HPP_NOEXCEPT
4341 {
4342 return m_device < rhs.m_device;
4343 }
4344 #endif
4345
4346 //=== VK_VERSION_1_0 ===
4347
4348
4349 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4350 PFN_vkVoidFunction getProcAddr( const char * pName, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4351 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4352 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4353 PFN_vkVoidFunction getProcAddr( const std::string & name, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4354 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4355
4356
4357 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4358 void destroy( const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4359 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4360 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4361 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;
4362 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4363
4364
4365 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4366 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;
4367 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4368 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4369 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;
4370 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4371
4372
4373 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
4374 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4375 VULKAN_HPP_NODISCARD Result waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4376 #else
4377 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4378 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
4379 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4380
4381
4382 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4383 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;
4384 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4385 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4386 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;
4387 # ifndef VULKAN_HPP_NO_SMART_HANDLE
4388 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4389 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;
4390 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
4391 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4392
4393
4394 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4395 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;
4396 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4397 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4398 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;
4399 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4400
4401
4402 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4403 void unmapMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4404
4405
4406 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4407 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;
4408 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4409 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4410 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;
4411 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4412
4413
4414 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4415 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;
4416 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4417 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4418 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;
4419 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4420
4421
4422 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4423 void getMemoryCommitment( VULKAN_HPP_NAMESPACE::DeviceMemory memory, VULKAN_HPP_NAMESPACE::DeviceSize * pCommittedMemoryInBytes, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4424 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4425 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4426 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;
4427 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4428
4429
4430 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
4431 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4432 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;
4433 #else
4434 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4435 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;
4436 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4437
4438
4439 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
4440 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4441 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;
4442 #else
4443 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4444 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;
4445 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4446
4447
4448 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4449 void getBufferMemoryRequirements( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::MemoryRequirements * pMemoryRequirements, 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 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;
4453 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4454
4455
4456 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4457 void getImageMemoryRequirements( VULKAN_HPP_NAMESPACE::Image image, VULKAN_HPP_NAMESPACE::MemoryRequirements * pMemoryRequirements, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4458 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4459 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4460 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;
4461 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4462
4463
4464 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4465 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;
4466 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4467 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4468 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;
4469 # ifndef VULKAN_HPP_NO_SMART_HANDLE
4470 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4471 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;
4472 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
4473 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4474
4475
4476 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4477 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;
4478 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4479 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4480 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;
4481 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4482
4483
4484 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4485 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;
4486 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4487 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4488 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;
4489 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4490
4491
4492 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4493 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;
4494 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4495 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4496 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;
4497 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4498
4499
4500 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
4501 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4502 VULKAN_HPP_NODISCARD Result getFenceStatus( VULKAN_HPP_NAMESPACE::Fence fence, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4503 #else
4504 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4505 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result getFenceStatus( VULKAN_HPP_NAMESPACE::Fence fence, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
4506 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4507
4508
4509 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4510 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;
4511 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4512 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4513 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;
4514 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4515
4516
4517 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4518 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;
4519 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4520 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4521 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;
4522 # ifndef VULKAN_HPP_NO_SMART_HANDLE
4523 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4524 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;
4525 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
4526 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4527
4528
4529 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4530 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;
4531 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4532 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4533 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;
4534 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4535
4536
4537 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4538 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;
4539 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4540 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4541 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;
4542 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4543
4544
4545 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4546 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;
4547 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4548 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4549 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;
4550 # ifndef VULKAN_HPP_NO_SMART_HANDLE
4551 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4552 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;
4553 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
4554 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4555
4556
4557 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4558 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;
4559 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4560 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4561 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;
4562 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4563
4564
4565 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4566 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;
4567 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4568 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4569 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;
4570 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4571
4572
4573 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
4574 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4575 VULKAN_HPP_NODISCARD Result getEventStatus( VULKAN_HPP_NAMESPACE::Event event, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4576 #else
4577 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4578 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result getEventStatus( VULKAN_HPP_NAMESPACE::Event event, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
4579 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4580
4581
4582 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
4583 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4584 VULKAN_HPP_NODISCARD Result setEvent( VULKAN_HPP_NAMESPACE::Event event, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4585 #else
4586 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4587 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;
4588 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4589
4590
4591 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
4592 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4593 VULKAN_HPP_NODISCARD Result resetEvent( VULKAN_HPP_NAMESPACE::Event event, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4594 #else
4595 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4596 typename ResultValueType<void>::type resetEvent( VULKAN_HPP_NAMESPACE::Event event, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
4597 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4598
4599
4600 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4601 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;
4602 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4603 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4604 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;
4605 # ifndef VULKAN_HPP_NO_SMART_HANDLE
4606 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4607 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;
4608 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
4609 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4610
4611
4612 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4613 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;
4614 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4615 template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4616 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;
4617 template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4618 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;
4619 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4620
4621
4622 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4623 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;
4624 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4625 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4626 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;
4627 # ifndef VULKAN_HPP_NO_SMART_HANDLE
4628 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4629 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;
4630 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
4631 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4632
4633
4634 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4635 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;
4636 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4637 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4638 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;
4639 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4640
4641
4642 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4643 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;
4644 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4645 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4646 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;
4647 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4648
4649
4650 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4651 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;
4652 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4653 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4654 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;
4655 # ifndef VULKAN_HPP_NO_SMART_HANDLE
4656 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4657 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;
4658 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
4659 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4660
4661
4662 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4663 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;
4664 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4665 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4666 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;
4667 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4668
4669
4670 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4671 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;
4672 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4673 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4674 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;
4675 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4676
4677
4678 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4679 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;
4680 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4681 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4682 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;
4683 # ifndef VULKAN_HPP_NO_SMART_HANDLE
4684 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4685 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;
4686 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
4687 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4688
4689
4690 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4691 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;
4692 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4693 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4694 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;
4695 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4696
4697
4698 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4699 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;
4700 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4701 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4702 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;
4703 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4704
4705
4706 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4707 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;
4708 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4709 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4710 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;
4711 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4712
4713
4714 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4715 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;
4716 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4717 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4718 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;
4719 # ifndef VULKAN_HPP_NO_SMART_HANDLE
4720 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4721 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;
4722 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
4723 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4724
4725
4726 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4727 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;
4728 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4729 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4730 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;
4731 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4732
4733
4734 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4735 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;
4736 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4737 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4738 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;
4739 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4740
4741
4742 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4743 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;
4744 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4745 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4746 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;
4747 # ifndef VULKAN_HPP_NO_SMART_HANDLE
4748 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4749 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;
4750 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
4751 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4752
4753
4754 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4755 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;
4756 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4757 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4758 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;
4759 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4760
4761
4762 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4763 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;
4764 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4765 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4766 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;
4767 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4768
4769
4770 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4771 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;
4772 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4773 template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4774 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;
4775 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>
4776 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;
4777 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4778 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;
4779 # ifndef VULKAN_HPP_NO_SMART_HANDLE
4780 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>>
4781 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;
4782 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>
4783 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;
4784 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4785 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;
4786 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
4787 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4788
4789
4790 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4791 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;
4792 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4793 template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4794 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;
4795 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>
4796 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;
4797 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4798 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;
4799 # ifndef VULKAN_HPP_NO_SMART_HANDLE
4800 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>>
4801 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;
4802 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>
4803 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;
4804 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4805 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;
4806 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
4807 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4808
4809
4810 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4811 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;
4812 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4813 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4814 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;
4815 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4816
4817
4818 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4819 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;
4820 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4821 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4822 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;
4823 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4824
4825
4826 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4827 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;
4828 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4829 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4830 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;
4831 # ifndef VULKAN_HPP_NO_SMART_HANDLE
4832 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4833 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;
4834 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
4835 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4836
4837
4838 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4839 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;
4840 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4841 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4842 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;
4843 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4844
4845
4846 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4847 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;
4848 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4849 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4850 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;
4851 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4852
4853
4854 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4855 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;
4856 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4857 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4858 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;
4859 # ifndef VULKAN_HPP_NO_SMART_HANDLE
4860 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4861 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;
4862 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
4863 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4864
4865
4866 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4867 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;
4868 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4869 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4870 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;
4871 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4872
4873
4874 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4875 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;
4876 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4877 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4878 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;
4879 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4880
4881
4882 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4883 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;
4884 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4885 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4886 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;
4887 # ifndef VULKAN_HPP_NO_SMART_HANDLE
4888 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4889 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;
4890 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
4891 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4892
4893
4894 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4895 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;
4896 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4897 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4898 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;
4899 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4900
4901
4902 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4903 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;
4904 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4905 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4906 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;
4907 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4908
4909
4910 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4911 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;
4912 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4913 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4914 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;
4915 # ifndef VULKAN_HPP_NO_SMART_HANDLE
4916 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4917 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;
4918 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
4919 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4920
4921
4922 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
4923 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4924 Result resetDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlags flags, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4925 #else
4926 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4927 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;
4928 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4929
4930
4931 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4932 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;
4933 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4934 template <typename DescriptorSetAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DescriptorSet>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4935 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;
4936 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>
4937 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;
4938 # ifndef VULKAN_HPP_NO_SMART_HANDLE
4939 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename DescriptorSetAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSet, Dispatch>>>
4940 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;
4941 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>
4942 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;
4943 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
4944 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4945
4946
4947 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4948 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;
4949 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4950 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4951 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;
4952 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4953
4954
4955 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4956 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;
4957 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4958 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4959 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;
4960 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4961
4962
4963 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4964 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;
4965 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4966 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4967 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;
4968 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4969
4970
4971 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4972 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;
4973 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4974 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4975 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;
4976 # ifndef VULKAN_HPP_NO_SMART_HANDLE
4977 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4978 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;
4979 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
4980 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4981
4982
4983 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4984 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;
4985 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4986 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4987 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;
4988 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4989
4990
4991 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4992 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;
4993 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4994 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4995 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;
4996 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4997
4998
4999 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5000 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;
5001 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5002 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5003 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;
5004 # ifndef VULKAN_HPP_NO_SMART_HANDLE
5005 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5006 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;
5007 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
5008 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5009
5010
5011 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5012 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;
5013 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5014 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5015 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;
5016 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5017
5018
5019 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5020 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;
5021 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5022 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5023 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;
5024 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5025
5026
5027 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5028 void getRenderAreaGranularity( VULKAN_HPP_NAMESPACE::RenderPass renderPass, VULKAN_HPP_NAMESPACE::Extent2D * pGranularity, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5029 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5030 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5031 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;
5032 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5033
5034
5035 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5036 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;
5037 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5038 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5039 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;
5040 # ifndef VULKAN_HPP_NO_SMART_HANDLE
5041 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5042 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;
5043 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
5044 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5045
5046
5047 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
5048 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5049 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;
5050 #else
5051 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5052 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;
5053 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
5054
5055
5056 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5057 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;
5058 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5059 template <typename CommandBufferAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CommandBuffer>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5060 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;
5061 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>
5062 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;
5063 # ifndef VULKAN_HPP_NO_SMART_HANDLE
5064 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename CommandBufferAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandBuffer, Dispatch>>>
5065 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;
5066 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>
5067 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;
5068 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
5069 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5070
5071
5072 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5073 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;
5074 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5075 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5076 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;
5077 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5078
5079
5080 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5081 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;
5082 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5083 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5084 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;
5085 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5086
5087 //=== VK_VERSION_1_1 ===
5088
5089
5090 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5091 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;
5092 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5093 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5094 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;
5095 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5096
5097
5098 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5099 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;
5100 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5101 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5102 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;
5103 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5104
5105
5106 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5107 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;
5108 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5109 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5110 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;
5111 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5112
5113
5114 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5115 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;
5116 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5117 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5118 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;
5119 template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5120 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;
5121 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5122
5123
5124 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5125 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;
5126 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5127 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5128 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;
5129 template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5130 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;
5131 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5132
5133
5134 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5135 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;
5136 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5137 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5138 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;
5139 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5140
5141
5142 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5143 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;
5144 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5145 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5146 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;
5147 # ifndef VULKAN_HPP_NO_SMART_HANDLE
5148 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5149 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;
5150 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
5151 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5152
5153
5154 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5155 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;
5156 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5157 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5158 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;
5159 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5160
5161
5162 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5163 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;
5164 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5165 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5166 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;
5167 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5168
5169
5170 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5171 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;
5172 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5173 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5174 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;
5175 template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5176 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;
5177 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5178
5179 //=== VK_VERSION_1_2 ===
5180
5181
5182 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5183 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;
5184 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5185 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5186 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;
5187 # ifndef VULKAN_HPP_NO_SMART_HANDLE
5188 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5189 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;
5190 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
5191 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5192
5193
5194 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5195 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;
5196
5197
5198 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5199 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;
5200 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5201 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5202 VULKAN_HPP_NODISCARD typename ResultValueType<uint64_t>::type getSemaphoreCounterValue( VULKAN_HPP_NAMESPACE::Semaphore semaphore, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
5203 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5204
5205
5206 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5207 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;
5208 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5209 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5210 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;
5211 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5212
5213
5214 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5215 VULKAN_HPP_NODISCARD Result signalSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo * pSignalInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5216 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5217 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5218 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;
5219 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5220
5221
5222 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5223 DeviceAddress getBufferAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5224 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5225 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5226 VULKAN_HPP_NAMESPACE::DeviceAddress getBufferAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5227 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5228
5229
5230 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5231 uint64_t getBufferOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5232 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5233 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5234 uint64_t getBufferOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5235 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5236
5237
5238 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5239 uint64_t getMemoryOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo * pInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5240 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5241 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5242 uint64_t getMemoryOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5243 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5244
5245 //=== VK_VERSION_1_3 ===
5246
5247
5248 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5249 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;
5250 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5251 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5252 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;
5253 # ifndef VULKAN_HPP_NO_SMART_HANDLE
5254 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5255 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;
5256 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
5257 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5258
5259
5260 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5261 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;
5262 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5263 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5264 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;
5265 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5266
5267
5268 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5269 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;
5270 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5271 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5272 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;
5273 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5274
5275
5276 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
5277 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5278 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;
5279 #else
5280 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5281 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;
5282 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
5283
5284
5285 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5286 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;
5287 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5288 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5289 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;
5290 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5291
5292
5293 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5294 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;
5295 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5296 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5297 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;
5298 template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5299 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;
5300 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5301
5302
5303 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5304 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;
5305 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5306 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5307 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;
5308 template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5309 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;
5310 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5311
5312
5313 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5314 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;
5315 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5316 template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5317 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;
5318 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>
5319 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;
5320 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5321
5322 //=== VKSC_VERSION_1_0 ===
5323
5324
5325 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5326 void getCommandPoolMemoryConsumption( VULKAN_HPP_NAMESPACE::CommandPool commandPool, VULKAN_HPP_NAMESPACE::CommandBuffer commandBuffer, VULKAN_HPP_NAMESPACE::CommandPoolMemoryConsumption * pConsumption, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5327 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5328 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5329 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::CommandPoolMemoryConsumption getCommandPoolMemoryConsumption( VULKAN_HPP_NAMESPACE::CommandPool commandPool, VULKAN_HPP_NAMESPACE::CommandBuffer commandBuffer VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5330 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5331
5332
5333 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5334 VULKAN_HPP_NODISCARD Result getFaultData( VULKAN_HPP_NAMESPACE::FaultQueryBehavior faultQueryBehavior, VULKAN_HPP_NAMESPACE::Bool32 * pUnrecordedFaults, uint32_t * pFaultCount, VULKAN_HPP_NAMESPACE::FaultData * pFaults, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5335 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5336 template <typename FaultDataAllocator = std::allocator<VULKAN_HPP_NAMESPACE::FaultData>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5337 VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<VULKAN_HPP_NAMESPACE::Bool32, std::vector<VULKAN_HPP_NAMESPACE::FaultData, FaultDataAllocator>>>::type getFaultData( VULKAN_HPP_NAMESPACE::FaultQueryBehavior faultQueryBehavior, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
5338 template <typename FaultDataAllocator = std::allocator<VULKAN_HPP_NAMESPACE::FaultData>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B2 = FaultDataAllocator, typename std::enable_if<std::is_same<typename B2::value_type, FaultData>::value, int>::type = 0>
5339 VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<VULKAN_HPP_NAMESPACE::Bool32, std::vector<VULKAN_HPP_NAMESPACE::FaultData, FaultDataAllocator>>>::type getFaultData( VULKAN_HPP_NAMESPACE::FaultQueryBehavior faultQueryBehavior, FaultDataAllocator & faultDataAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
5340 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5341
5342 //=== VK_KHR_swapchain ===
5343
5344
5345 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5346 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;
5347 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5348 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5349 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;
5350 # ifndef VULKAN_HPP_NO_SMART_HANDLE
5351 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5352 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;
5353 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
5354 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5355
5356
5357 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5358 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;
5359 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5360 template <typename ImageAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Image>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5361 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;
5362 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>
5363 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;
5364 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5365
5366
5367 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5368 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;
5369 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5370 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5371 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;
5372 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5373
5374
5375 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5376 VULKAN_HPP_NODISCARD Result getGroupPresentCapabilitiesKHR( VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR * pDeviceGroupPresentCapabilities, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5377 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5378 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5379 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR>::type getGroupPresentCapabilitiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
5380 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5381
5382
5383 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5384 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;
5385 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5386 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5387 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;
5388 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5389
5390
5391 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5392 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;
5393 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5394 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5395 VULKAN_HPP_NODISCARD ResultValue<uint32_t> acquireNextImage2KHR( const VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR & acquireInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
5396 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5397
5398 //=== VK_KHR_display_swapchain ===
5399
5400
5401 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5402 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;
5403 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5404 template <typename SwapchainKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SwapchainKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5405 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;
5406 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>
5407 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;
5408 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5409 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;
5410 # ifndef VULKAN_HPP_NO_SMART_HANDLE
5411 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename SwapchainKHRAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>>>
5412 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;
5413 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>
5414 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;
5415 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5416 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;
5417 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
5418 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5419
5420 //=== VK_KHR_external_memory_fd ===
5421
5422
5423 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5424 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;
5425 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5426 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5427 VULKAN_HPP_NODISCARD typename ResultValueType<int>::type getMemoryFdKHR( const VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR & getFdInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
5428 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5429
5430
5431 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5432 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;
5433 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5434 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5435 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;
5436 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5437
5438 //=== VK_KHR_external_semaphore_fd ===
5439
5440
5441 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5442 VULKAN_HPP_NODISCARD Result importSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR * pImportSemaphoreFdInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5443 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5444 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5445 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;
5446 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5447
5448
5449 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5450 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;
5451 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5452 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5453 VULKAN_HPP_NODISCARD typename ResultValueType<int>::type getSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR & getFdInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
5454 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5455
5456 //=== VK_EXT_display_control ===
5457
5458
5459 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5460 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;
5461 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5462 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5463 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;
5464 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5465
5466
5467 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5468 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;
5469 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5470 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5471 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;
5472 # ifndef VULKAN_HPP_NO_SMART_HANDLE
5473 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5474 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;
5475 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
5476 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5477
5478
5479 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5480 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;
5481 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5482 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5483 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;
5484 # ifndef VULKAN_HPP_NO_SMART_HANDLE
5485 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5486 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;
5487 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
5488 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5489
5490
5491 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5492 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;
5493 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5494 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5495 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;
5496 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5497
5498 //=== VK_EXT_hdr_metadata ===
5499
5500
5501 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5502 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;
5503 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5504 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5505 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;
5506 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5507
5508 //=== VK_KHR_shared_presentable_image ===
5509
5510
5511 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
5512 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5513 VULKAN_HPP_NODISCARD Result getSwapchainStatusKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5514 #else
5515 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5516 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result getSwapchainStatusKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
5517 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
5518
5519 //=== VK_KHR_external_fence_fd ===
5520
5521
5522 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5523 VULKAN_HPP_NODISCARD Result importFenceFdKHR( const VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR * pImportFenceFdInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5524 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5525 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5526 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;
5527 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5528
5529
5530 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5531 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;
5532 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5533 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5534 VULKAN_HPP_NODISCARD typename ResultValueType<int>::type getFenceFdKHR( const VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR & getFdInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
5535 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5536
5537 //=== VK_KHR_performance_query ===
5538
5539
5540 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5541 VULKAN_HPP_NODISCARD Result acquireProfilingLockKHR( const VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR * pInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5542 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5543 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5544 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;
5545 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5546
5547
5548 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5549 void releaseProfilingLockKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5550
5551 //=== VK_EXT_debug_utils ===
5552
5553
5554 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5555 VULKAN_HPP_NODISCARD Result setDebugUtilsObjectNameEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT * pNameInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5556 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5557 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5558 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;
5559 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5560
5561
5562 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5563 VULKAN_HPP_NODISCARD Result setDebugUtilsObjectTagEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT * pTagInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5564 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5565 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5566 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;
5567 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5568
5569 //=== VK_EXT_image_drm_format_modifier ===
5570
5571
5572 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5573 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;
5574 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5575 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5576 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;
5577 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5578
5579 //=== VK_EXT_external_memory_host ===
5580
5581
5582 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5583 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;
5584 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5585 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5586 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;
5587 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5588
5589 //=== VK_EXT_calibrated_timestamps ===
5590
5591
5592 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5593 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;
5594 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5595 template <typename Uint64_tAllocator = std::allocator<uint64_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5596 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;
5597 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>
5598 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;
5599 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5600 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;
5601 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5602
5603 #if defined( VK_USE_PLATFORM_SCI )
5604 //=== VK_NV_external_sci_sync ===
5605
5606
5607 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5608 VULKAN_HPP_NODISCARD Result getFenceSciSyncFenceNV( const VULKAN_HPP_NAMESPACE::FenceGetSciSyncInfoNV * pGetSciSyncHandleInfo, void * pHandle, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5609 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5610 template <typename HandleType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5611 VULKAN_HPP_NODISCARD typename ResultValueType<HandleType>::type getFenceSciSyncFenceNV( const VULKAN_HPP_NAMESPACE::FenceGetSciSyncInfoNV & getSciSyncHandleInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
5612 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5613
5614
5615 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5616 VULKAN_HPP_NODISCARD Result getFenceSciSyncObjNV( const VULKAN_HPP_NAMESPACE::FenceGetSciSyncInfoNV * pGetSciSyncHandleInfo, void * pHandle, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5617 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5618 template <typename HandleType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5619 VULKAN_HPP_NODISCARD typename ResultValueType<HandleType>::type getFenceSciSyncObjNV( const VULKAN_HPP_NAMESPACE::FenceGetSciSyncInfoNV & getSciSyncHandleInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
5620 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5621
5622
5623 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5624 VULKAN_HPP_NODISCARD Result importFenceSciSyncFenceNV( const VULKAN_HPP_NAMESPACE::ImportFenceSciSyncInfoNV * pImportFenceSciSyncInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5625 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5626 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5627 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type importFenceSciSyncFenceNV( const VULKAN_HPP_NAMESPACE::ImportFenceSciSyncInfoNV & importFenceSciSyncInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
5628 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5629
5630
5631 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5632 VULKAN_HPP_NODISCARD Result importFenceSciSyncObjNV( const VULKAN_HPP_NAMESPACE::ImportFenceSciSyncInfoNV * pImportFenceSciSyncInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5633 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5634 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5635 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type importFenceSciSyncObjNV( const VULKAN_HPP_NAMESPACE::ImportFenceSciSyncInfoNV & importFenceSciSyncInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
5636 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5637
5638
5639 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5640 VULKAN_HPP_NODISCARD Result getSemaphoreSciSyncObjNV( const VULKAN_HPP_NAMESPACE::SemaphoreGetSciSyncInfoNV * pGetSciSyncInfo, void * pHandle, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5641 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5642 template <typename HandleType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5643 VULKAN_HPP_NODISCARD typename ResultValueType<HandleType>::type getSemaphoreSciSyncObjNV( const VULKAN_HPP_NAMESPACE::SemaphoreGetSciSyncInfoNV & getSciSyncInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
5644 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5645
5646
5647 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5648 VULKAN_HPP_NODISCARD Result importSemaphoreSciSyncObjNV( const VULKAN_HPP_NAMESPACE::ImportSemaphoreSciSyncInfoNV * pImportSemaphoreSciSyncInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5649 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5650 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5651 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type importSemaphoreSciSyncObjNV( const VULKAN_HPP_NAMESPACE::ImportSemaphoreSciSyncInfoNV & importSemaphoreSciSyncInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
5652 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5653 #endif /*VK_USE_PLATFORM_SCI*/
5654
5655 #if defined( VK_USE_PLATFORM_SCI )
5656 //=== VK_NV_external_memory_sci_buf ===
5657
5658
5659 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5660 VULKAN_HPP_NODISCARD Result getMemorySciBufNV( const VULKAN_HPP_NAMESPACE::MemoryGetSciBufInfoNV * pGetSciBufInfo, NvSciBufObj * pHandle, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5661 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5662 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5663 VULKAN_HPP_NODISCARD typename ResultValueType<NvSciBufObj>::type getMemorySciBufNV( const VULKAN_HPP_NAMESPACE::MemoryGetSciBufInfoNV & getSciBufInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
5664 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5665 #endif /*VK_USE_PLATFORM_SCI*/
5666
5667 #if defined( VK_USE_PLATFORM_SCI )
5668 //=== VK_NV_external_sci_sync2 ===
5669
5670
5671 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5672 VULKAN_HPP_NODISCARD Result createSemaphoreSciSyncPoolNV( const VULKAN_HPP_NAMESPACE::SemaphoreSciSyncPoolCreateInfoNV * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::SemaphoreSciSyncPoolNV * pSemaphorePool, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5673 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5674 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5675 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SemaphoreSciSyncPoolNV>::type createSemaphoreSciSyncPoolNV( const VULKAN_HPP_NAMESPACE::SemaphoreSciSyncPoolCreateInfoNV & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
5676 # ifndef VULKAN_HPP_NO_SMART_HANDLE
5677 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5678 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SemaphoreSciSyncPoolNV, Dispatch>>::type createSemaphoreSciSyncPoolNVUnique( const VULKAN_HPP_NAMESPACE::SemaphoreSciSyncPoolCreateInfoNV & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
5679 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
5680 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5681 #endif /*VK_USE_PLATFORM_SCI*/
5682
5683 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
5684 //=== VK_QNX_external_memory_screen_buffer ===
5685
5686
5687 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5688 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;
5689 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5690 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5691 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;
5692 template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5693 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;
5694 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5695 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
5696
operator VkDevice() const5697 operator VkDevice() const VULKAN_HPP_NOEXCEPT
5698 {
5699 return m_device;
5700 }
5701
operator bool() const5702 explicit operator bool() const VULKAN_HPP_NOEXCEPT
5703 {
5704 return m_device != VK_NULL_HANDLE;
5705 }
5706
operator !() const5707 bool operator!() const VULKAN_HPP_NOEXCEPT
5708 {
5709 return m_device == VK_NULL_HANDLE;
5710 }
5711
5712 private:
5713 VkDevice m_device = {};
5714 };
5715
5716 template <>
5717 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDevice>
5718 {
5719 using Type = VULKAN_HPP_NAMESPACE::Device;
5720 };
5721
5722
5723 template <>
5724 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDevice>
5725 {
5726 using Type = VULKAN_HPP_NAMESPACE::Device;
5727 };
5728
5729
5730 template <>
5731 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Device>
5732 {
5733 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
5734 };
5735
5736 class DisplayModeKHR
5737 {
5738 public:
5739 using CType = VkDisplayModeKHR;
5740 using NativeType = VkDisplayModeKHR;
5741
5742 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDisplayModeKHR;
5743 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayModeKHR;
5744
5745 public:
5746 VULKAN_HPP_CONSTEXPR DisplayModeKHR() = default;
DisplayModeKHR(std::nullptr_t)5747 VULKAN_HPP_CONSTEXPR DisplayModeKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5748 {}
DisplayModeKHR(VkDisplayModeKHR displayModeKHR)5749 VULKAN_HPP_TYPESAFE_EXPLICIT DisplayModeKHR( VkDisplayModeKHR displayModeKHR ) VULKAN_HPP_NOEXCEPT
5750 : m_displayModeKHR( displayModeKHR )
5751 {}
5752
5753 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkDisplayModeKHR displayModeKHR)5754 DisplayModeKHR & operator=(VkDisplayModeKHR displayModeKHR) VULKAN_HPP_NOEXCEPT
5755 {
5756 m_displayModeKHR = displayModeKHR;
5757 return *this;
5758 }
5759 #endif
5760
operator =(std::nullptr_t)5761 DisplayModeKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5762 {
5763 m_displayModeKHR = {};
5764 return *this;
5765 }
5766
5767 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
5768 auto operator<=>( DisplayModeKHR const & ) const = default;
5769 #else
operator ==(DisplayModeKHR const & rhs) const5770 bool operator==( DisplayModeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
5771 {
5772 return m_displayModeKHR == rhs.m_displayModeKHR;
5773 }
5774
operator !=(DisplayModeKHR const & rhs) const5775 bool operator!=(DisplayModeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
5776 {
5777 return m_displayModeKHR != rhs.m_displayModeKHR;
5778 }
5779
operator <(DisplayModeKHR const & rhs) const5780 bool operator<(DisplayModeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
5781 {
5782 return m_displayModeKHR < rhs.m_displayModeKHR;
5783 }
5784 #endif
5785
operator VkDisplayModeKHR() const5786 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDisplayModeKHR() const VULKAN_HPP_NOEXCEPT
5787 {
5788 return m_displayModeKHR;
5789 }
5790
operator bool() const5791 explicit operator bool() const VULKAN_HPP_NOEXCEPT
5792 {
5793 return m_displayModeKHR != VK_NULL_HANDLE;
5794 }
5795
operator !() const5796 bool operator!() const VULKAN_HPP_NOEXCEPT
5797 {
5798 return m_displayModeKHR == VK_NULL_HANDLE;
5799 }
5800
5801 private:
5802 VkDisplayModeKHR m_displayModeKHR = {};
5803 };
5804
5805 template <>
5806 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDisplayModeKHR>
5807 {
5808 using Type = VULKAN_HPP_NAMESPACE::DisplayModeKHR;
5809 };
5810
5811
5812 template <>
5813 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayModeKHR>
5814 {
5815 using Type = VULKAN_HPP_NAMESPACE::DisplayModeKHR;
5816 };
5817
5818
5819 template <>
5820 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DisplayModeKHR>
5821 {
5822 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
5823 };
5824
5825 class PhysicalDevice
5826 {
5827 public:
5828 using CType = VkPhysicalDevice;
5829 using NativeType = VkPhysicalDevice;
5830
5831 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePhysicalDevice;
5832 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePhysicalDevice;
5833
5834 public:
5835 VULKAN_HPP_CONSTEXPR PhysicalDevice() = default;
PhysicalDevice(std::nullptr_t)5836 VULKAN_HPP_CONSTEXPR PhysicalDevice( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5837 {}
PhysicalDevice(VkPhysicalDevice physicalDevice)5838 PhysicalDevice( VkPhysicalDevice physicalDevice ) VULKAN_HPP_NOEXCEPT
5839 : m_physicalDevice( physicalDevice )
5840 {}
5841
operator =(VkPhysicalDevice physicalDevice)5842 PhysicalDevice & operator=(VkPhysicalDevice physicalDevice) VULKAN_HPP_NOEXCEPT
5843 {
5844 m_physicalDevice = physicalDevice;
5845 return *this;
5846 }
5847
operator =(std::nullptr_t)5848 PhysicalDevice & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5849 {
5850 m_physicalDevice = {};
5851 return *this;
5852 }
5853
5854 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
5855 auto operator<=>( PhysicalDevice const & ) const = default;
5856 #else
operator ==(PhysicalDevice const & rhs) const5857 bool operator==( PhysicalDevice const & rhs ) const VULKAN_HPP_NOEXCEPT
5858 {
5859 return m_physicalDevice == rhs.m_physicalDevice;
5860 }
5861
operator !=(PhysicalDevice const & rhs) const5862 bool operator!=(PhysicalDevice const & rhs ) const VULKAN_HPP_NOEXCEPT
5863 {
5864 return m_physicalDevice != rhs.m_physicalDevice;
5865 }
5866
operator <(PhysicalDevice const & rhs) const5867 bool operator<(PhysicalDevice const & rhs ) const VULKAN_HPP_NOEXCEPT
5868 {
5869 return m_physicalDevice < rhs.m_physicalDevice;
5870 }
5871 #endif
5872
5873 //=== VK_VERSION_1_0 ===
5874
5875
5876 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5877 void getFeatures( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures * pFeatures, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5878 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5879 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5880 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures getFeatures( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5881 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5882
5883
5884 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5885 void getFormatProperties( VULKAN_HPP_NAMESPACE::Format format, VULKAN_HPP_NAMESPACE::FormatProperties * pFormatProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5886 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5887 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5888 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;
5889 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5890
5891
5892 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5893 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;
5894 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5895 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5896 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;
5897 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5898
5899
5900 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5901 void getProperties( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties * pProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5902 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5903 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5904 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties getProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5905 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5906
5907
5908 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5909 void getQueueFamilyProperties( uint32_t * pQueueFamilyPropertyCount, VULKAN_HPP_NAMESPACE::QueueFamilyProperties * pQueueFamilyProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5910 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5911 template <typename QueueFamilyPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::QueueFamilyProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5912 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties, QueueFamilyPropertiesAllocator> getQueueFamilyProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
5913 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>
5914 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties, QueueFamilyPropertiesAllocator> getQueueFamilyProperties( QueueFamilyPropertiesAllocator & queueFamilyPropertiesAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
5915 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5916
5917
5918 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5919 void getMemoryProperties( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties * pMemoryProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5920 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5921 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5922 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties getMemoryProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5923 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5924
5925
5926 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5927 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;
5928 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5929 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5930 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;
5931 # ifndef VULKAN_HPP_NO_SMART_HANDLE
5932 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5933 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;
5934 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
5935 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5936
5937
5938 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5939 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;
5940 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5941 template <typename ExtensionPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::ExtensionProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5942 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;
5943 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>
5944 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;
5945 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5946
5947
5948 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5949 Result enumerateDeviceLayerProperties( uint32_t * pPropertyCount, VULKAN_HPP_NAMESPACE::LayerProperties * pProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5950 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5951 template <typename LayerPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::LayerProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5952 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::LayerProperties, LayerPropertiesAllocator> enumerateDeviceLayerProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
5953 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>
5954 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::LayerProperties, LayerPropertiesAllocator> enumerateDeviceLayerProperties( LayerPropertiesAllocator & layerPropertiesAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
5955 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5956
5957 //=== VK_VERSION_1_1 ===
5958
5959
5960 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5961 void getFeatures2( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 * pFeatures, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5962 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5963 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5964 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 getFeatures2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5965 template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5966 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getFeatures2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5967 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5968
5969
5970 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5971 void getProperties2( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 * pProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5972 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5973 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5974 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 getProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5975 template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5976 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5977 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5978
5979
5980 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5981 void getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format, VULKAN_HPP_NAMESPACE::FormatProperties2 * pFormatProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5982 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5983 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5984 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;
5985 template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5986 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;
5987 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5988
5989
5990 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5991 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;
5992 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5993 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5994 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;
5995 template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5996 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;
5997 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5998
5999
6000 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6001 void getQueueFamilyProperties2( uint32_t * pQueueFamilyPropertyCount, VULKAN_HPP_NAMESPACE::QueueFamilyProperties2 * pQueueFamilyProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6002 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6003 template <typename QueueFamilyProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6004 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2, QueueFamilyProperties2Allocator> getQueueFamilyProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
6005 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>
6006 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2, QueueFamilyProperties2Allocator> getQueueFamilyProperties2( QueueFamilyProperties2Allocator & queueFamilyProperties2Allocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
6007 template <typename StructureChain, typename StructureChainAllocator = std::allocator<StructureChain>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6008 VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator> getQueueFamilyProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
6009 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>
6010 VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator> getQueueFamilyProperties2( StructureChainAllocator & structureChainAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
6011 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6012
6013
6014 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6015 void getMemoryProperties2( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 * pMemoryProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6016 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6017 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6018 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 getMemoryProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6019 template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6020 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getMemoryProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6021 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6022
6023
6024 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6025 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;
6026 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6027 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6028 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;
6029 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6030
6031
6032 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6033 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;
6034 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6035 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6036 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;
6037 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6038
6039
6040 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6041 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;
6042 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6043 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6044 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;
6045 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6046
6047 //=== VK_VERSION_1_3 ===
6048
6049
6050 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6051 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;
6052 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6053 template <typename PhysicalDeviceToolPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6054 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator>>::type getToolProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
6055 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>
6056 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;
6057 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6058
6059 //=== VK_KHR_surface ===
6060
6061
6062 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6063 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;
6064 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6065 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6066 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;
6067 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6068
6069
6070 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6071 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;
6072 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6073 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6074 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;
6075 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6076
6077
6078 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6079 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;
6080 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6081 template <typename SurfaceFormatKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6082 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;
6083 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>
6084 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;
6085 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6086
6087
6088 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6089 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;
6090 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6091 template <typename PresentModeKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PresentModeKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6092 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;
6093 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>
6094 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;
6095 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6096
6097 //=== VK_KHR_swapchain ===
6098
6099
6100 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6101 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;
6102 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6103 template <typename Rect2DAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Rect2D>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6104 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;
6105 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>
6106 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;
6107 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6108
6109 //=== VK_KHR_display ===
6110
6111
6112 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6113 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;
6114 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6115 template <typename DisplayPropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6116 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR, DisplayPropertiesKHRAllocator>>::type getDisplayPropertiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
6117 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>
6118 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;
6119 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6120
6121
6122 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6123 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;
6124 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6125 template <typename DisplayPlanePropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6126 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR, DisplayPlanePropertiesKHRAllocator>>::type getDisplayPlanePropertiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
6127 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>
6128 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;
6129 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6130
6131
6132 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6133 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;
6134 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6135 template <typename DisplayKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6136 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;
6137 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>
6138 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;
6139 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6140
6141
6142 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6143 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;
6144 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6145 template <typename DisplayModePropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6146 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;
6147 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>
6148 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;
6149 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6150
6151
6152 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6153 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;
6154 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6155 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6156 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;
6157 # ifndef VULKAN_HPP_NO_SMART_HANDLE
6158 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6159 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;
6160 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
6161 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6162
6163
6164 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6165 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;
6166 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6167 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6168 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;
6169 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6170
6171 //=== VK_EXT_direct_mode_display ===
6172
6173
6174 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
6175 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6176 Result releaseDisplayEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6177 #else
6178 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6179 void releaseDisplayEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6180 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
6181
6182 //=== VK_EXT_display_surface_counter ===
6183
6184
6185 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6186 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;
6187 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6188 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6189 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;
6190 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6191
6192 //=== VK_KHR_performance_query ===
6193
6194
6195 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6196 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;
6197 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6198 template <typename PerformanceCounterKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR>, typename PerformanceCounterDescriptionKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6199 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;
6200 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>
6201 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;
6202 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6203
6204
6205 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6206 void getQueueFamilyPerformanceQueryPassesKHR( const VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR * pPerformanceQueryCreateInfo, uint32_t * pNumPasses, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6207 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6208 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6209 VULKAN_HPP_NODISCARD uint32_t getQueueFamilyPerformanceQueryPassesKHR( const VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR & performanceQueryCreateInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6210 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6211
6212 //=== VK_KHR_get_surface_capabilities2 ===
6213
6214
6215 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6216 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;
6217 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6218 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6219 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;
6220 template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6221 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;
6222 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6223
6224
6225 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6226 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;
6227 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6228 template <typename SurfaceFormat2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6229 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;
6230 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>
6231 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;
6232 template <typename StructureChain, typename StructureChainAllocator = std::allocator<StructureChain>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6233 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;
6234 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>
6235 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;
6236 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6237
6238 //=== VK_KHR_get_display_properties2 ===
6239
6240
6241 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6242 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;
6243 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6244 template <typename DisplayProperties2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6245 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR, DisplayProperties2KHRAllocator>>::type getDisplayProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
6246 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>
6247 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;
6248 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6249
6250
6251 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6252 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;
6253 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6254 template <typename DisplayPlaneProperties2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6255 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR, DisplayPlaneProperties2KHRAllocator>>::type getDisplayPlaneProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
6256 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>
6257 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;
6258 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6259
6260
6261 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6262 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;
6263 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6264 template <typename DisplayModeProperties2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6265 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;
6266 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>
6267 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;
6268 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6269
6270
6271 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6272 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;
6273 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6274 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6275 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;
6276 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6277
6278 //=== VK_EXT_sample_locations ===
6279
6280
6281 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6282 void getMultisamplePropertiesEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples, VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT * pMultisampleProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6283 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6284 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6285 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;
6286 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6287
6288 //=== VK_EXT_calibrated_timestamps ===
6289
6290
6291 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6292 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;
6293 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6294 template <typename TimeDomainEXTAllocator = std::allocator<VULKAN_HPP_NAMESPACE::TimeDomainEXT>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6295 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TimeDomainEXT, TimeDomainEXTAllocator>>::type getCalibrateableTimeDomainsEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
6296 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>
6297 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;
6298 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6299
6300 //=== VK_KHR_fragment_shading_rate ===
6301
6302
6303 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6304 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;
6305 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6306 template <typename PhysicalDeviceFragmentShadingRateKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6307 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR, PhysicalDeviceFragmentShadingRateKHRAllocator>>::type getFragmentShadingRatesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
6308 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>
6309 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;
6310 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6311
6312 //=== VK_KHR_object_refresh ===
6313
6314
6315 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6316 VULKAN_HPP_NODISCARD Result getRefreshableObjectTypesKHR( uint32_t * pRefreshableObjectTypeCount, VULKAN_HPP_NAMESPACE::ObjectType * pRefreshableObjectTypes, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6317 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6318 template <typename ObjectTypeAllocator = std::allocator<VULKAN_HPP_NAMESPACE::ObjectType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6319 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::ObjectType, ObjectTypeAllocator>>::type getRefreshableObjectTypesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
6320 template <typename ObjectTypeAllocator = std::allocator<VULKAN_HPP_NAMESPACE::ObjectType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = ObjectTypeAllocator, typename std::enable_if<std::is_same<typename B1::value_type, ObjectType>::value, int>::type = 0>
6321 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::ObjectType, ObjectTypeAllocator>>::type getRefreshableObjectTypesKHR( ObjectTypeAllocator & objectTypeAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
6322 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6323
6324 #if defined( VK_USE_PLATFORM_SCI )
6325 //=== VK_NV_external_sci_sync ===
6326
6327
6328 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6329 VULKAN_HPP_NODISCARD Result getSciSyncAttributesNV( const VULKAN_HPP_NAMESPACE::SciSyncAttributesInfoNV * pSciSyncAttributesInfo, NvSciSyncAttrList pAttributes, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6330 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6331 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6332 typename ResultValueType<void>::type getSciSyncAttributesNV( const VULKAN_HPP_NAMESPACE::SciSyncAttributesInfoNV & sciSyncAttributesInfo, NvSciSyncAttrList pAttributes, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
6333 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6334 #endif /*VK_USE_PLATFORM_SCI*/
6335
6336 #if defined( VK_USE_PLATFORM_SCI )
6337 //=== VK_NV_external_memory_sci_buf ===
6338
6339
6340 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6341 VULKAN_HPP_NODISCARD Result getExternalMemorySciBufPropertiesNV( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, NvSciBufObj handle, VULKAN_HPP_NAMESPACE::MemorySciBufPropertiesNV * pMemorySciBufProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6342 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6343 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6344 VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::MemorySciBufPropertiesNV>::type getExternalMemorySciBufPropertiesNV( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, NvSciBufObj handle, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
6345 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6346
6347
6348 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
6349 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6350 VULKAN_HPP_NODISCARD Result getSciBufAttributesNV( NvSciBufAttrList pAttributes, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6351 #else
6352 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6353 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type getSciBufAttributesNV( NvSciBufAttrList pAttributes, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
6354 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
6355 #endif /*VK_USE_PLATFORM_SCI*/
6356
operator VkPhysicalDevice() const6357 operator VkPhysicalDevice() const VULKAN_HPP_NOEXCEPT
6358 {
6359 return m_physicalDevice;
6360 }
6361
operator bool() const6362 explicit operator bool() const VULKAN_HPP_NOEXCEPT
6363 {
6364 return m_physicalDevice != VK_NULL_HANDLE;
6365 }
6366
operator !() const6367 bool operator!() const VULKAN_HPP_NOEXCEPT
6368 {
6369 return m_physicalDevice == VK_NULL_HANDLE;
6370 }
6371
6372 private:
6373 VkPhysicalDevice m_physicalDevice = {};
6374 };
6375
6376 template <>
6377 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePhysicalDevice>
6378 {
6379 using Type = VULKAN_HPP_NAMESPACE::PhysicalDevice;
6380 };
6381
6382
6383 template <>
6384 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePhysicalDevice>
6385 {
6386 using Type = VULKAN_HPP_NAMESPACE::PhysicalDevice;
6387 };
6388
6389
6390 template <>
6391 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PhysicalDevice>
6392 {
6393 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
6394 };
6395
6396 class Instance
6397 {
6398 public:
6399 using CType = VkInstance;
6400 using NativeType = VkInstance;
6401
6402 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eInstance;
6403 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eInstance;
6404
6405 public:
6406 VULKAN_HPP_CONSTEXPR Instance() = default;
Instance(std::nullptr_t)6407 VULKAN_HPP_CONSTEXPR Instance( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6408 {}
Instance(VkInstance instance)6409 Instance( VkInstance instance ) VULKAN_HPP_NOEXCEPT
6410 : m_instance( instance )
6411 {}
6412
operator =(VkInstance instance)6413 Instance & operator=(VkInstance instance) VULKAN_HPP_NOEXCEPT
6414 {
6415 m_instance = instance;
6416 return *this;
6417 }
6418
operator =(std::nullptr_t)6419 Instance & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6420 {
6421 m_instance = {};
6422 return *this;
6423 }
6424
6425 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
6426 auto operator<=>( Instance const & ) const = default;
6427 #else
operator ==(Instance const & rhs) const6428 bool operator==( Instance const & rhs ) const VULKAN_HPP_NOEXCEPT
6429 {
6430 return m_instance == rhs.m_instance;
6431 }
6432
operator !=(Instance const & rhs) const6433 bool operator!=(Instance const & rhs ) const VULKAN_HPP_NOEXCEPT
6434 {
6435 return m_instance != rhs.m_instance;
6436 }
6437
operator <(Instance const & rhs) const6438 bool operator<(Instance const & rhs ) const VULKAN_HPP_NOEXCEPT
6439 {
6440 return m_instance < rhs.m_instance;
6441 }
6442 #endif
6443
6444 //=== VK_VERSION_1_0 ===
6445
6446
6447 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6448 void destroy( const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6449 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6450 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6451 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;
6452 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6453
6454
6455 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6456 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;
6457 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6458 template <typename PhysicalDeviceAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDevice>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6459 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDevice, PhysicalDeviceAllocator>>::type enumeratePhysicalDevices( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
6460 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>
6461 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;
6462 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6463
6464
6465 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6466 PFN_vkVoidFunction getProcAddr( const char * pName, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6467 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6468 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6469 PFN_vkVoidFunction getProcAddr( const std::string & name, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6470 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6471
6472 //=== VK_VERSION_1_1 ===
6473
6474
6475 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6476 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;
6477 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6478 template <typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6479 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type enumeratePhysicalDeviceGroups( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
6480 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>
6481 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;
6482 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6483
6484 //=== VK_KHR_surface ===
6485
6486
6487 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6488 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;
6489 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6490 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6491 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;
6492 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6493
6494
6495 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6496 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;
6497 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6498 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6499 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;
6500 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6501
6502 //=== VK_KHR_display ===
6503
6504
6505 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6506 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;
6507 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6508 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6509 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;
6510 # ifndef VULKAN_HPP_NO_SMART_HANDLE
6511 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6512 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;
6513 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
6514 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6515
6516 //=== VK_EXT_debug_utils ===
6517
6518
6519 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6520 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;
6521 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6522 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6523 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;
6524 # ifndef VULKAN_HPP_NO_SMART_HANDLE
6525 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6526 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;
6527 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
6528 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6529
6530
6531 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6532 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;
6533 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6534 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6535 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;
6536 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6537
6538
6539 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6540 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;
6541 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6542 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6543 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;
6544 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6545
6546
6547 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6548 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;
6549 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6550 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6551 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;
6552 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6553
6554 //=== VK_EXT_headless_surface ===
6555
6556
6557 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6558 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;
6559 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6560 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6561 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;
6562 # ifndef VULKAN_HPP_NO_SMART_HANDLE
6563 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6564 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;
6565 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
6566 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6567
operator VkInstance() const6568 operator VkInstance() const VULKAN_HPP_NOEXCEPT
6569 {
6570 return m_instance;
6571 }
6572
operator bool() const6573 explicit operator bool() const VULKAN_HPP_NOEXCEPT
6574 {
6575 return m_instance != VK_NULL_HANDLE;
6576 }
6577
operator !() const6578 bool operator!() const VULKAN_HPP_NOEXCEPT
6579 {
6580 return m_instance == VK_NULL_HANDLE;
6581 }
6582
6583 private:
6584 VkInstance m_instance = {};
6585 };
6586
6587 template <>
6588 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eInstance>
6589 {
6590 using Type = VULKAN_HPP_NAMESPACE::Instance;
6591 };
6592
6593
6594 template <>
6595 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eInstance>
6596 {
6597 using Type = VULKAN_HPP_NAMESPACE::Instance;
6598 };
6599
6600
6601 template <>
6602 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Instance>
6603 {
6604 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
6605 };
6606
6607 //=== VK_VERSION_1_0 ===
6608
6609
6610 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6611 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;
6612 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6613 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6614 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 );
6615 # ifndef VULKAN_HPP_NO_SMART_HANDLE
6616 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6617 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 );
6618 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
6619 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6620
6621
6622 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6623 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;
6624 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6625 template <typename ExtensionPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::ExtensionProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6626 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 );
6627 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>
6628 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 );
6629 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6630
6631
6632 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6633 VULKAN_HPP_NODISCARD Result enumerateInstanceLayerProperties( uint32_t * pPropertyCount, VULKAN_HPP_NAMESPACE::LayerProperties * pProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT;
6634 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6635 template <typename LayerPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::LayerProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6636 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::LayerProperties, LayerPropertiesAllocator>>::type enumerateInstanceLayerProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
6637 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>
6638 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::LayerProperties, LayerPropertiesAllocator>>::type enumerateInstanceLayerProperties( LayerPropertiesAllocator & layerPropertiesAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
6639 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6640
6641 //=== VK_VERSION_1_1 ===
6642
6643
6644 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6645 VULKAN_HPP_NODISCARD Result enumerateInstanceVersion( uint32_t * pApiVersion, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT;
6646 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6647 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6648 VULKAN_HPP_NODISCARD typename ResultValueType<uint32_t>::type enumerateInstanceVersion( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
6649 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6650
6651 class ShaderModule
6652 {
6653 public:
6654 using CType = VkShaderModule;
6655 using NativeType = VkShaderModule;
6656
6657 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eShaderModule;
6658 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eShaderModule;
6659
6660 public:
6661 VULKAN_HPP_CONSTEXPR ShaderModule() = default;
ShaderModule(std::nullptr_t)6662 VULKAN_HPP_CONSTEXPR ShaderModule( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6663 {}
ShaderModule(VkShaderModule shaderModule)6664 VULKAN_HPP_TYPESAFE_EXPLICIT ShaderModule( VkShaderModule shaderModule ) VULKAN_HPP_NOEXCEPT
6665 : m_shaderModule( shaderModule )
6666 {}
6667
6668 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkShaderModule shaderModule)6669 ShaderModule & operator=(VkShaderModule shaderModule) VULKAN_HPP_NOEXCEPT
6670 {
6671 m_shaderModule = shaderModule;
6672 return *this;
6673 }
6674 #endif
6675
operator =(std::nullptr_t)6676 ShaderModule & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6677 {
6678 m_shaderModule = {};
6679 return *this;
6680 }
6681
6682 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
6683 auto operator<=>( ShaderModule const & ) const = default;
6684 #else
operator ==(ShaderModule const & rhs) const6685 bool operator==( ShaderModule const & rhs ) const VULKAN_HPP_NOEXCEPT
6686 {
6687 return m_shaderModule == rhs.m_shaderModule;
6688 }
6689
operator !=(ShaderModule const & rhs) const6690 bool operator!=(ShaderModule const & rhs ) const VULKAN_HPP_NOEXCEPT
6691 {
6692 return m_shaderModule != rhs.m_shaderModule;
6693 }
6694
operator <(ShaderModule const & rhs) const6695 bool operator<(ShaderModule const & rhs ) const VULKAN_HPP_NOEXCEPT
6696 {
6697 return m_shaderModule < rhs.m_shaderModule;
6698 }
6699 #endif
6700
operator VkShaderModule() const6701 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkShaderModule() const VULKAN_HPP_NOEXCEPT
6702 {
6703 return m_shaderModule;
6704 }
6705
operator bool() const6706 explicit operator bool() const VULKAN_HPP_NOEXCEPT
6707 {
6708 return m_shaderModule != VK_NULL_HANDLE;
6709 }
6710
operator !() const6711 bool operator!() const VULKAN_HPP_NOEXCEPT
6712 {
6713 return m_shaderModule == VK_NULL_HANDLE;
6714 }
6715
6716 private:
6717 VkShaderModule m_shaderModule = {};
6718 };
6719
6720 template <>
6721 struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eShaderModule>
6722 {
6723 using Type = VULKAN_HPP_NAMESPACE::ShaderModule;
6724 };
6725
6726
6727 template <>
6728 struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eShaderModule>
6729 {
6730 using Type = VULKAN_HPP_NAMESPACE::ShaderModule;
6731 };
6732
6733
6734 template <>
6735 struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::ShaderModule>
6736 {
6737 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
6738 };
6739
6740 } // namespace VULKAN_HPP_NAMESPACE
6741
6742 // operators to compare vk::-handles with nullptr
6743 template <typename T>
operator ==(const T & v,std::nullptr_t)6744 typename std::enable_if<VULKAN_HPP_NAMESPACE::isVulkanHandleType<T>::value, bool>::type operator==( const T & v, std::nullptr_t )
6745 {
6746 return !v;
6747 }
6748
6749 template <typename T>
operator ==(std::nullptr_t,const T & v)6750 typename std::enable_if<VULKAN_HPP_NAMESPACE::isVulkanHandleType<T>::value, bool>::type operator==( std::nullptr_t, const T & v )
6751 {
6752 return !v;
6753 }
6754
6755 template <typename T>
operator !=(const T & v,std::nullptr_t)6756 typename std::enable_if<VULKAN_HPP_NAMESPACE::isVulkanHandleType<T>::value, bool>::type operator!=( const T & v, std::nullptr_t )
6757 {
6758 return v;
6759 }
6760
6761 template <typename T>
operator !=(std::nullptr_t,const T & v)6762 typename std::enable_if<VULKAN_HPP_NAMESPACE::isVulkanHandleType<T>::value, bool>::type operator!=( std::nullptr_t, const T & v )
6763 {
6764 return v;
6765 }
6766 #endif
6767